Ejemplo: crear un AWS Fargate servicio mediante el AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Crea un CDK proyectoCree un servicio FargateLimpieza

Esta es la guía para AWS CDK desarrolladores de la versión 2. La CDK versión anterior entró en mantenimiento el 1 de junio de 2022 y finalizó el soporte 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 AWS Fargate servicio mediante el AWS CDK

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

Amazon ECS es un servicio de administración de contenedores rápido y altamente escalable que facilita la ejecución, la detención y la administración de Docker contenedores en un clúster. Puedes alojar tu clúster en una infraestructura sin servidor gestionada por Amazon ECS lanzando tus servicios o tareas mediante el tipo de lanzamiento Fargate. Para tener más control, puede alojar sus tareas en un clúster de instancias de Amazon Elastic Compute Cloud (AmazonEC2) que administra mediante el tipo de EC2 lanzamiento de Amazon.

En este ejemplo, lanzamos algunos servicios mediante el tipo de lanzamiento Fargate. Si ha utilizado el AWS Management Console 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

La ECS construcción de Amazon utilizada en este ejemplo le ayuda a utilizar AWS los servicios al ofrecer las siguientes ventajas:

  • Configura automáticamente un balanceador de carga.

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

  • Ordena automáticamente la dependencia entre el servicio y el balanceador de cargas asociado a un grupo objetivo, donde se AWS CDK impone el orden correcto de creación del listener antes de que se cree una instancia.

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

  • Valida anticipadamente las combinaciones de parámetros. Esto expone los AWS CloudFormation problemas 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 AWS CDK pueden detectar un error de configuración y emitir un error cuando sintetizamos nuestra aplicación.

  • Añade automáticamente permisos para Amazon Elastic Container Registry (AmazonECR) si utilizamos una imagen de AmazonECR.

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

    Además, 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.

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

  • Proporciona soporte de activos para que podamos implementar una fuente desde nuestra máquina ECS en Amazon 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 Docker imagen.

importante

Las ApplicationLoadBalancedFargateService construcciones que utilizaremos incluyen numerosos AWS componentes, algunos de los cuales tienen costes nada despreciables si se dejan aprovisionados en nuestra AWS cuenta, incluso si no los utilizamos. Asegúrate de limpiar (cdk destroy) si sigues este ejemplo.

Crea un CDK proyecto

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

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 nuestroIDE.

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

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

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

cdk synth

Cree un servicio Fargate

Hay dos formas diferentes de ejecutar nuestras tareas de contenedores con AmazonECS:

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

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

Para este ejemplo, crearemos un servicio Fargate que se ejecute en un ECS clúster de Amazon, encabezado por un Application Load Balancer con acceso a Internet.

Añadimos las siguientes importaciones del módulo AWS Construct Library 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, añadimos 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 docenas de pasos que debe realizar para implementar nuestra aplicación.

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

Limpieza

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

cdk destroy