Ejemplo: Crear un servicio de AWS Fargate con AWS CDK. - AWS Kit Cloud Development Kit (AWS CDK) v2
Crear un proyecto CDKCrear un servicio de FargateLimpieza

Esta es la guía para desarrolladores de AWS CDK v2. La primera versión del CDK pasó a la etapa de mantenimiento el 1.° de junio de 2022 y no cuenta con soporte desde el 1.° de junio de 2023.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ejemplo: Crear un servicio de AWS Fargate con AWS CDK.

En este ejemplo, le mostramos cómo crear un servicio de AWS Fargate que se ejecute en un clúster de Amazon Elastic Container Service (Amazon ECS) encabezado por un Equilibrador de carga de aplicación con acceso a Internet a partir de una imagen de Amazon ECR.

Amazon ECS es un servicio de administración de contenedores muy escalable y rápido que facilita la tarea de ejecutar, detener y administrar contenedores de Docker en un clúster. Puede alojar el clúster en una infraestructura sin servidor administrada por Amazon ECS. Para ello, lance los servicios o las tareas con el tipo de lanzamiento Fargate. Si desea más control, puede alojar las tareas en un clúster de instancias de Amazon Elastic Compute Cloud (Amazon EC2) administrado mediante el tipo de lanzamiento Amazon EC2.

En este ejemplo, lanzamos algunos servicios mediante el tipo de lanzamiento de Fargate. Si ha utilizado la consola de administración de AWS para crear un servicio Fargate, sabrá que hay muchos pasos a seguir para realizar esa tarea. AWS tiene varios tutoriales y temas de documentación que le guiarán a través de la creación de un servicio Fargate, entre los que se incluyen:

En este ejemplo se crea un servicio Fargate similar mediante AWS CDK

El constructo de Amazon ECS utilizado en este ejemplo le ayuda a utilizar los servicios de AWS al ofrecer las siguientes ventajas:

  • Configura automáticamente un equilibrador de carga.

  • Abre automáticamente un grupo de seguridad para los equilibradores de carga. Esto permite que los equilibradores de carga se comuniquen con las instancias sin tener que crear explícitamente un grupo de seguridad.

  • Ordena automáticamente la dependencia entre el servicio y el equilibrador de carga asociado a un grupo objetivo, donde el AWS CDK impone el orden correcto de creación del oyente antes de crear una instancia.

  • Configura automáticamente los datos de usuario en grupos que se escalan automáticamente. Esto crea la configuración correcta para asociar un clúster a las AMI.

  • Valida anticipadamente las combinaciones de parámetros. Esto expone los problemas de AWS CloudFormation antes, lo que ahorra tiempo de implementación. Por ejemplo, en función de la tarea, es fácil configurar incorrectamente los ajustes de memoria. Anteriormente, no se producía ningún error hasta que implementábamos nuestra aplicación. Pero ahora el AWS CDK puede detectar un error de configuración y emitir un error cuando sintetizamos nuestra aplicación.

  • Agrega automáticamente permisos para Amazon Elastic Container Registry (Amazon ECR) si utilizamos una imagen de Amazon ECR.

  • Escala automáticamente. AWS CDK proporciona un método para que podamos escalar automáticamente las instancias cuando utilizamos un clúster de Amazon EC2. Esto ocurre automáticamente cuando utilizamos una instancia en un clúster de Fargate.

    Además, el AWS CDK evita que se elimine una instancia cuando el escalado automático intenta detener una instancia, pero una tarea se está ejecutando o está programada en esa instancia.

    Antes, teníamos que crear una función de Lambda para disponer de esta funcionalidad.

  • Proporciona soporte de activos para que podamos implementar una fuente desde nuestra máquina en Amazon ECS en un solo paso. Anteriormente, para utilizar una fuente de aplicación, teníamos que realizar varios pasos manuales, como subirla a Amazon ECR y crear una imagen de Docker.

importante

Los constructos de ApplicationLoadBalancedFargateService que utilizaremos incluyen numerosos componentes de AWS, algunos de los cuales tienen costos nada despreciables si se dejan aprovisionados en nuestra cuenta de AWS, incluso si no los utilizamos. Asegúrese de limpiar (cdk destroy) si sigue este ejemplo.

Crear un proyecto CDK

Empezamos por crear un proyecto CDK. Este es un directorio que almacena nuestro código de AWS CDK, incluida nuestra aplicación CDK.

TypeScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
JavaScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
Python
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
Java
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java

Ahora podemos importar el proyecto Maven a nuestro IDE.

C#
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp

Ahora podemos abrir src/MyEcsConstruct.sln en Visual Studio.

A continuación, ejecutamos la aplicación y confirmamos que cree una pila vacía.

cdk synth

Crear un servicio de Fargate

Existen dos formas diferentes de ejecutar nuestras tareas de contenedores con Amazon ECS:

  • Usar el tipo de lanzamiento de Fargate, en el que Amazon ECS administra por nosotros las máquinas físicas en las que se ejecutan nuestros contenedores.

  • Usar el tipo de lanzamiento de EC2, en el que nos encargamos de la administración, por ejemplo, especificando el escalado automático.

Para este ejemplo, crearemos un servicio Fargate que se ejecute en un clúster de Amazon ECS, presentado por un Equilibrador de carga de aplicación con acceso a Internet.

Añadimos las siguientes importaciones del módulo de la Biblioteca de constructos de AWS a nuestro archivo de pila:

TypeScript

Archivo: lib/my_ecs_construct-stack.ts 

import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";
JavaScript

Archivo: lib/my_ecs_construct-stack.js 

const ec2 = require("aws-cdk-lib/aws-ec2");
const ecs = require("aws-cdk-lib/aws-ecs");
const ecs_patterns = require("aws-cdk-lib/aws-ecs-patterns");
Python

Archivo: my_ecs_construct/my_ecs_construct_stack.py 

from aws_cdk import (aws_ec2 as ec2, aws_ecs as ecs,
                     aws_ecs_patterns as ecs_patterns)
Java

Archivo: src/main/java/com/myorg/MyEcsConstructStack.java 

import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
C#

Archivo: src/MyEcsConstruct/MyEcsConstructStack.cs 

using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;

Dentro de nuestra pila, agregamos el siguiente código:

TypeScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
JavaScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
Python
        vpc = ec2.Vpc(self, "MyVpc", max_azs=3)     # default is all AZs in region

        cluster = ecs.Cluster(self, "MyCluster", vpc=vpc)

        ecs_patterns.ApplicationLoadBalancedFargateService(self, "MyFargateService",
            cluster=cluster,            # Required
            cpu=512,                    # Default is 256
            desired_count=6,            # Default is 1
            task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
            memory_limit_mib=2048,      # Default is 512
            public_load_balancer=True)  # Default is True
Java
        Vpc vpc = Vpc.Builder.create(this, "MyVpc")
                            .maxAzs(3)  // Default is all AZs in region
                            .build();

        Cluster cluster = Cluster.Builder.create(this, "MyCluster")
                            .vpc(vpc).build();

        // Create a load-balanced Fargate service and make it public
        ApplicationLoadBalancedFargateService.Builder.create(this, "MyFargateService")
                    .cluster(cluster)           // Required
                    .cpu(512)                   // Default is 256
                     .desiredCount(6)            // Default is 1
                     .taskImageOptions(
                             ApplicationLoadBalancedTaskImageOptions.builder()
                                     .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
                                     .build())
                     .memoryLimitMiB(2048)       // Default is 512
                     .publicLoadBalancer(true)   // Default is true
                     .build();
C#
            var vpc = new Vpc(this, "MyVpc", new VpcProps
            {
                MaxAzs = 3 // Default is all AZs in region
            });

            var cluster = new Cluster(this, "MyCluster", new ClusterProps
            {
                Vpc = vpc
            });

            // Create a load-balanced Fargate service and make it public
            new ApplicationLoadBalancedFargateService(this, "MyFargateService",
                new ApplicationLoadBalancedFargateServiceProps
                {
                    Cluster = cluster,          // Required
                    DesiredCount = 6,           // Default is 1
                    TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
                    {
                        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
                    },
                    MemoryLimitMiB = 2048,      // Default is 256
                    PublicLoadBalancer = true   // Default is true
                }
            );

A continuación, validamos nuestro código ejecutando lo siguiente para sintetizar nuestra pila:

cdk synth

La pila consta de cientos de líneas, por lo que no la mostraremos aquí. La pila debe contener una instancia predeterminada, una subred privada y una subred pública para las tres zonas de disponibilidad y un grupo de seguridad.

Para implementar la pila, ejecutamos lo siguiente:

cdk deploy

AWS CloudFormation muestra información sobre las decenas de pasos que debe realizar para implementar nuestra aplicación.

Una vez completada la implementación, habremos creado correctamente un servicio Amazon ECS con tecnología Fargate para ejecutar una imagen de Docker.

Limpieza

Como práctica recomendada de mantenimiento general y para minimizar los costos innecesarios, eliminamos nuestra pila una vez finalizada:

cdk destroy