Passaggio 1: configura il tuo progetto AWS CDK Passaggio 2: utilizzare il AWS CDK per definire un server Web containerizzato su Fargate Fase 3: Test del server Web Fase 4: pulizia Passaggi successivi

Creazione di ECS risorse Amazon utilizzando il AWS CDK

AWS Cloud Development Kit (AWS CDK) Si tratta di un framework Infrastructure-as-Code (IAC) che puoi utilizzare per definire l'infrastruttura AWS cloud utilizzando un linguaggio di programmazione a tua scelta. Per definire la tua infrastruttura cloud, devi prima scrivere un'app (in uno dei linguaggi supportati) che CDK contenga uno o più stack. Quindi, la sintetizzi in un AWS CloudFormation modello e distribuisci le tue risorse su. Account AWS Segui i passaggi descritti in questo argomento per distribuire un server Web containerizzato con Amazon Elastic Container Service (AmazonECS) e su AWS CDK Fargate.

La AWS Construct Library, inclusa inCDK, fornisce moduli che puoi usare per modellare le risorse fornite. AWS servizi Per i servizi più diffusi, la libreria fornisce costrutti curati con impostazioni predefinite intelligenti e best practice. Uno di questi moduli, aws-ecs-patterns, fornisce astrazioni di alto livello che possono essere utilizzate per definire il servizio containerizzato e tutte le risorse di supporto necessarie in poche righe di codice.

In questo argomento viene utilizzato il costrutto ApplicationLoadBalancedFargateService. Questo costrutto implementa un ECS servizio Amazon su Fargate con un sistema di bilanciamento del carico delle applicazioni. Il aws-ecs-patterns modulo include anche costrutti che utilizzano un sistema di bilanciamento del carico di rete e vengono eseguiti su Amazon. EC2

Prima di iniziare questa attività, configura il tuo ambiente di AWS CDK sviluppo e installalo AWS CDK eseguendo il comando seguente. Per istruzioni su come configurare l'ambiente di AWS CDK sviluppo, consulta Getting Started With the AWS CDK - Prerequisiti.


npm install -g aws-cdk

Nota

Queste istruzioni presuppongono che tu stia usando AWS CDK v2.

Argomenti

Passaggio 1: configura il tuo progetto AWS CDK
Passaggio 2: utilizzare il AWS CDK per definire un server Web containerizzato su Fargate
Fase 3: Test del server Web
Fase 4: pulizia
Passaggi successivi

Passaggio 1: configura il tuo progetto AWS CDK

Crea una directory per la tua nuova AWS CDK app e inizializza il progetto.

Nota

Il modello di AWS CDK applicazione utilizza il nome della directory del progetto per generare nomi per file e classi sorgente. In questo esempio, la directory è denominata hello-ecs. Se utilizzi un nome di directory del progetto diverso, l'app non corrisponderà a queste istruzioni.

AWS CDK v2 include costrutti stabili per tutti AWS servizi in un unico pacchetto chiamato. aws-cdk-lib Questo pacchetto viene installato come dipendenza quando inizializzi il progetto. Quando lavori con determinati linguaggi di programmazione, il pacchetto viene installato quando crei il progetto per la prima volta. Questo argomento spiega come utilizzare un costrutto Amazon ECS Patterns, che fornisce astrazioni di alto livello per lavorare con Amazon. ECS Questo modulo si basa su ECS costrutti Amazon e altri costrutti per fornire le risorse necessarie alla tua applicazione AmazonECS.

I nomi che usi per importare queste librerie nella tua CDK applicazione potrebbero differire leggermente a seconda del linguaggio di programmazione utilizzato. A titolo di riferimento, i seguenti sono i nomi utilizzati in ogni linguaggio CDK di programmazione supportato.

Passaggio 2: utilizzare il AWS CDK per definire un server Web containerizzato su Fargate

Usa l'immagine del contenitore da. amazon-ecs-sample DockerHub Questa immagine contiene un'app PHP Web che funziona su Amazon Linux 2.

Nel AWS CDK progetto che hai creato, modifica il file che contiene la definizione dello stack in modo che sia simile a uno dei seguenti esempi.

Nota

Uno stack è un'unità di implementazione. Tutte le risorse devono trovarsi in uno stack e tutte le risorse in uno stack vengono implementate contemporaneamente. Se una risorsa non viene implementata, verrà eseguito il rollback di tutte le altre risorse già implementate. Un' AWS CDK app può contenere più stack e le risorse in uno stack possono fare riferimento a risorse in un altro stack.

TypeScript

Aggiorna lib/hello-ecs-stack.ts in modo che assomigli a quanto segue.


import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as ecsp from 'aws-cdk-lib/aws-ecs-patterns';

export class HelloEcsStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', {
      taskImageOptions: {
        image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
      },
      publicLoadBalancer: true
    });
  }
}

JavaScript

Aggiorna lib/hello-ecs-stack.js in modo che assomigli a quanto segue.


const cdk = require('aws-cdk-lib');
const { Construct } = require('constructs');
const ecs = require('aws-cdk-lib/aws-ecs');
const ecsp = require('aws-cdk-lib/aws-ecs-patterns');

class HelloEcsStack extends cdk.Stack {
  constructor(scope = Construct, id = string, props = cdk.StackProps) {
    super(scope, id, props);

    new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', {
      taskImageOptions: {
        image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
      },
      publicLoadBalancer: true
    });
  }
}

module.exports = { HelloEcsStack }

Python

Aggiorna hello-ecs/hello_ecs_stack.py in modo che assomigli a quanto segue.


import aws_cdk as cdk
from constructs import Construct

import aws_cdk.aws_ecs as ecs
import aws_cdk.aws_ecs_patterns as ecsp

class HelloEcsStack(cdk.Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        ecsp.ApplicationLoadBalancedFargateService(self, "MyWebServer",
            task_image_options=ecsp.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
            public_load_balancer=True
        )

Java

Aggiorna src/main/java/com.myorg/HelloEcsStack.java in modo che assomigli a quanto segue.


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;

import software.amazon.awscdk.services.ecs.ContainerImage;
import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedFargateService;
import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedTaskImageOptions;

public class HelloEcsStack extends Stack {
    public HelloEcsStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public HelloEcsStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        ApplicationLoadBalancedFargateService.Builder.create(this, "MyWebServer")
        	.taskImageOptions(ApplicationLoadBalancedTaskImageOptions.builder()
        			.image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
        			.build())
        	.publicLoadBalancer(true)
        	.build();        
    }
}

C#

Aggiorna src/HelloEcs/HelloEcsStack.cs in modo che assomigli a quanto segue.


using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;
namespace HelloEcs
{
    public class HelloEcsStack : Stack
    {
        internal HelloEcsStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            new ApplicationLoadBalancedFargateService(this, "MyWebServer",
                new ApplicationLoadBalancedFargateServiceProps
                {
                    TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
                    {
                        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
                    },
                    PublicLoadBalancer = true
                });
        }
    }
}

Go

Aggiorna hello-ecs.go in modo che assomigli a quanto segue.


package main

import (
	"github.com/aws/aws-cdk-go/awscdk/v2"
	// "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
	"github.com/aws/aws-cdk-go/awscdk/v2/awsecs"
	"github.com/aws/aws-cdk-go/awscdk/v2/awsecspatterns"
	"github.com/aws/constructs-go/constructs/v10"
	"github.com/aws/jsii-runtime-go"
)

type HelloEcsStackProps struct {
	awscdk.StackProps
}

func NewHelloEcsStack(scope constructs.Construct, id string, props *HelloEcsStackProps) awscdk.Stack {
	var sprops awscdk.StackProps
	if props != nil {
		sprops = props.StackProps
	}
	stack := awscdk.NewStack(scope, &id, &sprops)

	// The code that defines your stack goes here

	// example resource
	// queue := awssqs.NewQueue(stack, jsii.String("HelloEcsQueue"), &awssqs.QueueProps{
	// 	VisibilityTimeout: awscdk.Duration_Seconds(jsii.Number(300)),
	// })
	res := awsecspatterns.NewApplicationLoadBalancedFargateService(stack, jsii.String("MyWebServer"),
		&awsecspatterns.ApplicationLoadBalancedFargateServiceProps{
			TaskImageOptions: &awsecspatterns.ApplicationLoadBalancedTaskImageOptions{
				Image: awsecs.ContainerImage_FromRegistry(jsii.String("amazon/amazon-ecs-sample"), &awsecs.RepositoryImageProps{}),
			},
		},
	)
	awscdk.NewCfnOutput(stack, jsii.String("LoadBalancerDNS"), &awscdk.CfnOutputProps{Value: res.LoadBalancer().LoadBalancerDnsName()})

	return stack
}

func main() {
	defer jsii.Close()

	app := awscdk.NewApp(nil)

	NewHelloEcsStack(app, "HelloEcsStack", &HelloEcsStackProps{
		awscdk.StackProps{
			Env: env(),
		},
	})

	app.Synth(nil)
}

// env determines the AWS environment (account+region) in which our stack is to
// be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html
func env() *awscdk.Environment {
	// If unspecified, this stack will be "environment-agnostic".
	// Account/Region-dependent features and context lookups will not work, but a
	// single synthesized template can be deployed anywhere.
	//---------------------------------------------------------------------------
	return nil

	// Uncomment if you know exactly what account and region you want to deploy
	// the stack to. This is the recommendation for production stacks.
	//---------------------------------------------------------------------------
	// return &awscdk.Environment{
	//  Account: jsii.String("123456789012"),
	//  Region:  jsii.String("us-east-1"),
	// }

	// Uncomment to specialize this stack for the AWS Account and Region that are
	// implied by the current CLI configuration. This is recommended for dev
	// stacks.
	//---------------------------------------------------------------------------
	// return &awscdk.Environment{
	//  Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
	//  Region:  jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
	// }
}

Il frammento breve precedente include quanto segue:

Il nome logico del servizio, MyWebServer.
L'immagine del contenitore che è stata ottenuta da:. DockerHub amazon/amazon-ecs-sample
Altre informazioni pertinenti, ad esempio il fatto che il load balancer ha un indirizzo pubblico ed è accessibile da Internet.

AWS CDK Creerà tutte le risorse necessarie per distribuire il server Web, incluse le seguenti risorse. Queste risorse sono state omesse in questo esempio.

ECSCluster Amazon
EC2Istanze Amazon VPC e Amazon
Gruppo con scalabilità automatica
Application Load Balancer
Ruoli e policy IAM

Alcune risorse fornite automaticamente sono condivise da tutti i ECS servizi Amazon definiti nello stack.

Salva il file di origine, quindi esegui il comando cdk synth nella directory principale dell'applicazione. AWS CDK Esegue l'app e sintetizza un AWS CloudFormation modello a partire da essa, quindi visualizza il modello. Il modello è un file di circa 600 YAML righe. L'inizio del file è mostrato di seguito. Il modello potrebbe differire da questo esempio.



Resources:
  MyWebServerLB3B5FD3AB:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      LoadBalancerAttributes:
        - Key: deletion_protection.enabled
          Value: "false"
      Scheme: internet-facing
      SecurityGroups:
        - Fn::GetAtt:
            - MyWebServerLBSecurityGroup01B285AA
            - GroupId
      Subnets:
        - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1Subnet3C273B99
        - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2Subnet95FF715A
      Type: application
    DependsOn:
      - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1DefaultRouteFF4E2178
      - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2DefaultRouteB1375520
    Metadata:
      aws:cdk:path: HelloEcsStack/MyWebServer/LB/Resource
  MyWebServerLBSecurityGroup01B285AA:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Automatically created Security Group for ELB HelloEcsStackMyWebServerLB06757F57
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          Description: Allow from anyone on port 80
          FromPort: 80
          IpProtocol: tcp
          ToPort: 80
      VpcId:
        Ref: EcsDefaultClusterMnL3mNNYNVpc7788A521
    Metadata:
      aws:cdk:path: HelloEcsStack/MyWebServer/LB/SecurityGroup/Resource
# and so on for another few hundred lines

Per distribuire il servizio nella tua Account AWS, esegui il cdk deploy comando nella directory principale dell'applicazione. Ti viene chiesto di approvare le IAM politiche che hanno generato. AWS CDK

La distribuzione richiede diversi minuti, durante i quali vengono AWS CDK create diverse risorse. Le ultime righe dell'output della distribuzione includono il nome host pubblico del sistema di bilanciamento del carico e quello del nuovo server Web. URL Sono i seguenti:


Outputs:
HelloEcsStack.MyWebServerLoadBalancerDNSXXXXXXX = Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com
HelloEcsStack.MyWebServerServiceURLYYYYYYYY = http://Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com

Fase 3: Test del server Web

Copia l'URLoutput dell'implementazione e incollalo nel tuo browser web. Viene visualizzato il seguente messaggio di benvenuto dal server Web.

Schermata dell'applicazione di ECS esempio Amazon. L'output indica che «La tua applicazione è ora in esecuzione su AmazonECS».

Fase 4: pulizia

Dopo aver finito con il server web, termina il servizio utilizzando il comando CDK eseguendo il cdk destroy comando nella directory principale dell'applicazione. In questo modo si evita di incorrere in addebiti non intenzionali in futuro.

Passaggi successivi

Per ulteriori informazioni su come sviluppare AWS un'infrastruttura utilizzando la AWS CDK, consulta la Guida per gli AWS CDK sviluppatori.

Per informazioni sulla scrittura di AWS CDK app nella lingua che preferisci, consulta quanto segue:

Per ulteriori informazioni sui moduli AWS Construct Library utilizzati in questo argomento, consultate le seguenti panoramiche AWS CDK API di riferimento.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Distribuzione di un'ECSapplicazione Amazon di esempio utilizzando Copilot AWS CLI

Creazione di risorse utilizzando AWS CloudFormation