Iniziare a usare AWS CDK

GUIDA ALLE OPERAZIONI DI BASE

Modulo 3: Creazione del primo progetto AWS CDK

In questo modulo, creerai un'infrastruttura utilizzando AWS Cloud Development Kit (CDK).

Introduzione

In questa guida, utilizzeremo la CLI di AWS CDK per creare un nuovo progetto di infrastruttura tramite TypeScript. Impareremo anche come scrivere una risorsa semplice e come sintetizzare e implementare il codice CDK. La sintetizzazione è il modo in cui CDK trasforma il codice dell'infrastruttura in modelli di AWS CloudFormation.

Argomenti affrontati

  • Creazione di un nuovo progetto CDK con TypeScript.
  • Scrittura di una risorsa semplice in CDK (VPC).
  • Sintetizzazione del codice CDK in un modello CloudFormation.
  • Implementazione dell'infrastruttura nell'account AWS.

 Tempo richiesto per il completamento

15 minuti

 Prerequisiti del modulo

  • Account AWS con accesso da amministratore**
  • Browser consigliato: l'ultima versione di Chrome o Firefox

[**]Gli account creati nelle ultime 24 ore potrebbero non avere ancora accesso a tutti servizi richiesti per questo tutorial.

Implementazione

Creazione di un nuovo progetto CDK

Per creare un nuovo progetto CDK, utilizzeremo la CLI di CDK. Per iniziare, crea una directory vuota sul sistema e accedi a essa. Ora utilizzeremo cdk init per creare un nuovo progetto CDK TypeScript:

mkdir cdk-demo
cd cdk-demo
cdk init --language typescript

In questo modo verrà creata la struttura della cartella e saranno installati alcuni dei moduli necessari per un progetto CDK TypeScript. L'output dovrebbe avere il seguente aspetto:

Applying project template app for typescript
# Welcome to your CDK TypeScript project!

This is a blank project for TypeScript development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

## Useful commands

 * `npm run build`   compile typescript to js
 * `npm run watch`   watch for changes and compile
 * `npm run test`    perform the jest unit tests
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk synth`       emits the synthesized CloudFormation template

Initializing a new git repository...
Executing npm install...
npm WARN deprecated urix@0.1.0: Please see https://github.com/lydell/urix#deprecated
npm WARN deprecated resolve-url@0.2.1: https://github.com/lydell/resolve-url#deprecated
npm WARN deprecated sane@4.1.0: some dependency vulnerabilities fixed, support for node < 10 dropped, and newer ECMAScript syntax/features added
npm notice
npm notice New minor version of npm available! 7.19.0 -> 7.20.1
npm notice Changelog: https://github.com/npm/cli/releases/tag/v7.20.1
npm notice Run npm install -g npm@7.20.1 to update!
npm notice
✅ All done!

Vengono inoltre forniti i comandi necessari per aiutarti a iniziare a utilizzare il progetto CDK. Ora siamo pronti a scrivere il nostro primo codice CDK per creare l'infrastruttura.

Creazione dell'infrastruttura

Per iniziare a costruire un progetto, un punto di partenza comune è creare e definire una rete virtuale logicamente isolata, cioè un Amazon Virtual Private Cloud (VPC). Prima di creare il nostro primo VPC, è necessario comprendere i file che il comando cdk init ha creato.

Costruzione e implementazione dell'applicazione CDK

├── bin
│   └── cdk-demo.ts
├── cdk.json
├── jest.config.js
├── lib
│   └── cdk-demo-stack.ts
├── package.json
├── package-lock.json
├── README.md
├── test
│   └── cdk-demo.test.ts
└── tsconfig.json

Ecco alcuni dei file importanti e il loro utilizzo:

  • bin/cdk-project.ts - Si tratta del punto d'ingresso all'applicazione CDK. Questo file carica/crea tutti gli stack definiti in lib/*
  • lib/cdk-project-stack.ts - In questo file è definita l'applicazione CDK principale. Puoi includere qui le risorse e le proprietà.
  • package.json - In questo file si definiscono le dipendenze del progetto, nonché alcune informazioni aggiuntive e gli script di costruzione (npm buildnpm testnpm watch).
  • cdk.json - Questo file indica al kit di strumenti come eseguire l'applicazione, nonché alcuni parametri e impostazioni aggiuntivi relativi a CDK e al progetto.

In questa guida, ci concentreremo sui file lib/cdk-demo.ts e bin/cdk-demo.ts per creare l'infrastruttura. Aggiungiamo del codice.

Definizione di alcuni dettagli nell'applicazione

Prima di definire il VPC nello stack principale, dobbiamo assicurarci di effettuare l'implementazione nell'account e nella regione corretti. Nonostante il CDK ricavi queste informazioni dalla configurazione aws cli locale, è preferibile configurarle manualmente nel codice CDK per evitare che vengano impostati valori errati quando tale configurazione cambia. In questa guida è necessario fare ciò per via delle impostazioni che definiremo nel VPC. Se non specifichi tali informazioni, lo stack sarà indipendente dall'ambiente, ma alcune caratteristiche e ricerche di contesti non funzioneranno. Per ulteriori informazioni, consulta Ambienti nella documentazione.

Modifica il tuo stack bin/cdk-demo.ts in modo che abbia questo aspetto. Assicurati di sostituire l'ID dell'account AWS con il numero corretto e di scegliere la regione corretta. Per seguire questa guida, ti consigliamo di scegliere us-east-1 or eu-west-1.

#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from '@aws-cdk/core';
import { CdkDemoStack } from '../lib/cdk-demo-stack';

const app = new cdk.App();
new CdkDemoStack(app, 'CdkDemoStack', {
  env: { account: '123456789012', region: 'eu-west-1' },

});

Ora è tutto pronto per scrivere la tua prima risorsa.

Codice per il VPC

Creeremo un VPC con due sottoreti pubbliche distribuite in due zone di disponibilità. Prima di cominciare a scrivere il codice, dobbiamo spiegare e installare i moduli di Construct Library. Servizi diversi sono pacchettizzati in moduli che consentono di aggiungere solo le dipendenze necessarie per l'infrastruttura di cui effettui il provisioning. I moduli possono essere per un singolo servizio, ad esempio AWS Amplify, o per più servizi, ad esempio Amazon EC2. In questa guida, avremo bisogno del modulo Amazon EC2, che include anche il supporto per i VPC di AWS.

Per installare il modulo, utilizzeremo npm. Esegui il comando seguente mentre ti trovi nella directory del progetto:

npm install @aws-cdk/aws-ec2

In questo modo saranno installati tutti i moduli necessari con cui lavoreremo. Se controlli il file package.json, vedrai che è stato aggiunto anche lì.

Ora è tutto pronto per creare il nostro VPC. Apri la definizione dello stack in lib/cdk-demo.ts. Quando apri per la prima volta il file, dovrebbe avere un aspetto simile al seguente:

import * as cdk from '@aws-cdk/core';

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

    // The code that defines your stack goes here
  }
}

Questo è lo scheletro del nostro progetto. Se eseguissi CDK ora, nessuna risorsa sarebbe creata poiché non ne abbiamo ancora definita alcuna. Per iniziare a creare il VPC, è necessario importare il modulo installato e fare riferimento ai moduli di codice al suo interno. Importeremo le classi Vpc e SubnetType.

import * as cdk from '@aws-cdk/core';

// CHANGE: This is where you import the classes from the module:
import { Vpc, SubnetType } from '@aws-cdk/aws-ec2';

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

    // The code that defines your stack goes here
  }
}

Durante la creazione di un VPC, ci sono varie proprietà che possiamo impostare per adattarlo alle nostre necessità. Di default, sarà creato un VPC in 3 zone di disponibilità (AZ), con sottoreti pubbliche e private (con un singolo Gateway Internet e 3 Gateway NAT). In questa guida, desideriamo creare solo una configurazione molto semplice che si estende in 2 AZ, ognuna delle quali dispone di una sottorete pubblica. Per una spiegazione più dettagliata delle differenze, leggi questo documento

Per creare il VPC, specificheremo due AZ e i dettagli per creare una sottorete pubblica come mostrato di seguito:

import * as cdk from '@aws-cdk/core';
import { Vpc, SubnetType } from '@aws-cdk/aws-ec2';

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

    // The code that defines your stack goes here
    // CHANGE: We have created the vpc object from the Vpc class.
    const vpc = new Vpc(this, 'MainVpc',{
    
    // CHANGE: this is where we define how many AZs to use
    maxAzs: 2,
      
   // CHANGE: We define a single subnet configuration per AZ.
      subnetConfiguration:  [
        {
          // CHANGE: this is it's CIDR mask so 255.255.255.0
          cidrMask: 24,

          // CHANGE: a name for each of these subnets
          name: 'public-subnet',

          // CHANGE: and the subnet type to be used - here we will have
          // a public subnet. There are other options available here.
          subnetType: SubnetType.PUBLIC
        },
      ]
    });
  }
}

Ora è tutto pronto per implementare questa modifica dell'infrastruttura nel nostro account.

Fase di implementazione

È il momento di testare l'implementazione. Per verificare che il codice sia valido, puoi eseguire npm build, che compilerà TypeScript in JavaScript. Se tale operazione viene eseguita correttamente, puoi eseguire il comando deploy:

cdk deploy

Tale comando compilerà TypeScript in JavaScript e creerà un set di modifica CloudFormation per implementare la modifica. CDK gestisce tutto ciò al tuo posto, insieme al caricamento del file del modello in S3 e l'utilizzo di CloudFormation per eseguirlo. Dovresti visualizzare un output simile al seguente:

# cdk deploy
CdkDemoStack: deploying...
CdkDemoStack: creating CloudFormation changeset...
[··························································] (0/13)

3:50:17 PM | CREATE_IN_PROGRESS   | AWS::CloudFormation::Stack            | CdkDemoStack
3:50:21 PM | CREATE_IN_PROGRESS   | AWS::EC2::InternetGateway             | MainVpc/IGW
3:50:21 PM | CREATE_IN_PROGRESS   | AWS::EC2::VPC                         | MainVpc
3:50:22 PM | CREATE_IN_PROGRESS   | AWS::CDK::Metadata                    | CDKMetadata/Default

Dopo qualche minuto, dovresti visualizzare una spunta verde e un ARN (Amazon Resource Name) dello stack CloudFormation appena creato. Il nuovo VPC è ora implementato e pronto per essere utilizzato.

Eliminazione delle risorse (facoltativa)

Il VPC creato in questa guida non comporterà un costo mensile, ma c'è una quota che consente a ogni regione in un account di avere massimo 5 VPC. Se necessario, puoi aumentare questo limite tramite un ticket di supporto. Se desideri rimuovere le risorse appena create, puoi eseguire il comando cdk destroy, il quale rimuoverà tutte le risorse tramite lo stack CloudFormation creato in precedenza.

cdk destroy

Dovresti ricevere il seguente messaggio. Dopo aver premuto y e Invio, verrà avviata la rimozione dell'intera infrastruttura e verranno forniti degli aggiornamenti. Una volta completata l'operazione, visualizzerai quanto segue:

Are you sure you want to delete: CdkEcsInfraStack (y/n)? y
CdkEcsInfraStack: destroying...

✅  CdkEcsInfraStack: destroyed

Conclusione

Congratulazioni! Hai completato la guida Iniziare a utilizzare AWS CDK. In questa guida abbiamo creato il nostro primo progetto AWS CDK in TypeScript creando un VPC. Abbiamo visto come inizializzare un nuovo progetto CDK e usarlo per creare questa infrastruttura. Questo codice CDK e il VPC saranno utilizzati nelle guide future. Ti consigliamo ti consultare la guida all'implementazione della tua prima applicazione Web. 

Se desideri approfondire concetti come strutture delle cartelle, costrutti, stack e app, ti consigliamo di leggere la documentazione

Facci sapere com'è andata.

Grazie per il tuo feedback
Siamo contenti che questa pagina ti sia stata d’aiuto. Vuoi condividere ulteriori dettagli per aiutarci a continuare a migliorare?
Chiudi
Grazie per il tuo feedback
Ci dispiace che questa pagina non ti sia stata d'aiuto. Vuoi condividere ulteriori dettagli per aiutarci a continuare a migliorare?
Chiudi