Creazione o estensione di costrutti

Che cos'è un costrutto

Un costrutto è l'elemento costitutivo di base di un'applicazione. AWS CDK Un costrutto può rappresentare una singola AWS risorsa, ad esempio un bucket Amazon Simple Storage Service (Amazon S3), oppure può essere un'astrazione di livello superiore composta da più risorse correlate. AWS I componenti di un costrutto possono includere una coda di lavoro con la capacità di elaborazione associata o un lavoro pianificato con risorse di monitoraggio e una dashboard. AWS CDK Include una raccolta di costrutti chiamata Construct Library. AWS La libreria contiene costrutti per tutti. Servizio AWS Puoi utilizzare Construct Hub per scoprire costrutti aggiuntivi forniti da AWS terze parti e dalla comunità open source. AWS CDK

Quali sono i diversi tipi di costrutti

Esistono tre diversi tipi di costrutti per: AWS CDK

• Costrutti L1: i costrutti di livello 1, o L1, sono esattamente le risorse definite da CloudFormation —né più né meno. È necessario fornire personalmente le risorse necessarie per la configurazione. Questi costrutti L1 sono molto semplici e devono essere configurati manualmente. I costrutti L1 hanno un Cfn prefisso e corrispondono direttamente alle specifiche. CloudFormation Servizi AWS I nuovi vengono supportati non AWS CDK appena CloudFormation viene fornito il supporto per questi servizi. CfnBucketè un buon esempio di costrutto L1. Questa classe rappresenta un bucket S3 in cui è necessario configurare esplicitamente tutte le proprietà. Ti consigliamo di utilizzare un costrutto L1 solo se non riesci a trovare il costrutto L2 o L3 corrispondente.

• Costrutti L2: i costrutti di livello 2, ovvero L2, presentano un codice boilerplate e una logica glue comuni. Questi costrutti sono dotati di comode impostazioni predefinite e riducono la quantità di conoscenze necessarie su di essi. I costrutti L2 si basano sugli intenti APIs per costruire le risorse e in genere incapsulano i moduli L1 corrispondenti. Un buon esempio di costrutto L2 è Bucket. Questa classe crea un bucket S3 con proprietà e metodi predefiniti come bucket. addLifeCycleRule (), che aggiunge una regola del ciclo di vita al bucket.

• Costrutti L3: un costrutto di livello 3, ovvero L3, è detto pattern. I costrutti L3 sono progettati per aiutarti a completare attività comuni in AWS, che spesso coinvolgono più tipi di risorse. Si tratta di costrutti ancora più specifici e rigidi dei costrutti L2 e servono a un caso d'uso specifico. Ad esempio, il. aws-ecs-patterns ApplicationLoadBalancedFargateServiceconstruct rappresenta un'architettura che include un cluster di AWS Fargate contenitori che utilizza un Application Load Balancer. Un altro esempio è aws-apigateway. LambdaRestApicostruire. Questo costrutto rappresenta un Amazon API Gateway API supportato da una funzione Lambda.

Man mano che i livelli dei costrutti aumentano, si formulano più ipotesi sull'uso che ne verrà fatto. Ciò consente di fornire interfacce con impostazioni predefinite più efficaci per casi d'uso altamente specifici.

Come creare il proprio costrutto

Per definire il proprio costrutto, è necessario seguire un approccio specifico. Questo perché tutti i costrutti estendono la classe Construct. La classe Construct è l'elemento base dell'albero dei costrutti. I costrutti sono implementati in classi che estendono la classe di base Construct. Tutti i costrutti accettano tre parametri al momento dell'inizializzazione:

• Ambito: il genitore o il proprietario di un costrutto, uno stack o un altro costrutto, che ne determina la posizione nell'albero dei costrutti. In genere devi superare this (o self in Python), che rappresenta l'oggetto corrente, per lo scope.

• id: un identificatore che deve essere univoco all'interno di tale scope. L'identificatore funge da namespace per tutto ciò che è definito all'interno del costrutto corrente e viene utilizzato per allocare identità univoche, ad esempio nomi di risorse e logiche. CloudFormation IDs

• Props: un insieme di proprietà che definiscono la configurazione iniziale del costrutto.

L'esempio seguente mostra come definire un costrutto.

import { Construct } from 'constructs';

export interface CustomProps {
  // List all the properties 
  Name: string;
}
export class MyConstruct extends Construct {
  constructor(scope: Construct, id: string, props: CustomProps) {
    super(scope, id);

    // TODO
  }
}

Creazione o estensione di un costrutto L2

Un costrutto L2 rappresenta un «componente cloud» e incapsula tutto ciò che CloudFormation deve essere necessario per creare il componente. Un costrutto L2 può contenere una o più AWS risorse e sei libero di personalizzare tu stesso il costrutto. Il vantaggio di creare o estendere un costrutto L2 è che potete riutilizzare i componenti negli stack senza ridefinire il codice. CloudFormation È possibile semplicemente importare il costrutto come classe.

Quando esiste una relazione «is a» con un costrutto esistente, è possibile estendere un costrutto esistente per aggiungere funzionalità predefinite aggiuntive. È consigliabile riutilizzare le proprietà del costrutto L2 esistente. È possibile sovrascrivere le proprietà modificandole direttamente nel costruttore.

L'esempio seguente mostra come allinearsi alle best practice ed estendere un costrutto L2 esistente denominato s3.Bucket. L'estensione stabilisce proprietà predefinite, come versioned, publicReadAccess, blockPublicAccess, per assicurarsi che tutti gli oggetti (in questo esempio, i bucket S3) creati a partire da questo nuovo costrutto presentino sempre questi valori predefiniti impostati.

import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';
export class MySecureBucket extends s3.Bucket {
  constructor(scope: Construct, id: string, props?: s3.BucketProps) {

    super(scope, id, { 
      ...props, 
      versioned: true,
      publicReadAccess: false,
      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL
    });
  }
}  

Creazione di un costrutto L3

La composizione è la scelta migliore quando esiste una relazione «ha» con una composizione del costrutto esistente. Composizione significa che costruisci il tuo costrutto personale su altri costrutti esistenti. Puoi creare un pattern personalizzato per racchiudere tutte le risorse e i relativi valori predefiniti all'interno di un unico costrutto L3 di livello superiore che può essere condiviso. Il vantaggio di creare i propri costrutti (pattern) L3 è la possibilità di riutilizzare i componenti negli stack senza ridefinire il codice. È possibile semplicemente importare il costrutto come classe. Questi pattern sono progettati per aiutare gli utenti a effettuare in modo conciso il provisioning di più risorse in base a pattern comuni con una quantità limitata di conoscenze.

Il seguente esempio di codice crea un AWS CDK costrutto chiamato. ExampleConstruct È possibile utilizzare questo costrutto come modello per definire i propri componenti cloud.

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';

export interface ExampleConstructProps {
  //insert properties you wish to expose
}

export class ExampleConstruct extends Construct {
  constructor(scope: Construct, id: string, props: ExampleConstructProps) {
    super(scope, id);
    //Insert the AWS components you wish to integrate
  }
}

L'esempio seguente mostra come importare il costrutto appena creato nell' AWS CDK applicazione o nello stack.

import { ExampleConstruct } from './lib/construct-name';

L'esempio seguente mostra come creare un'istanza del costrutto esteso a partire dalla classe base.

import { ExampleConstruct } from './lib/construct-name';

new ExampleConstruct(this, 'newConstruct', {
  //insert props which you exposed in the interface `ExampleConstructProps`
});

Per ulteriori informazioni, consultate AWS CDK Workshop nella documentazione del AWS CDK Workshop.

Escape hatch

È possibile utilizzare una porta di fuga in AWS CDK per salire di un livello di astrazione in modo da poter accedere al livello inferiore dei costrutti. Le botole di fuga vengono utilizzate per estendere il costrutto a funzionalità che non sono esposte nella versione corrente di ma disponibili in. AWS CloudFormation

È consigliabile utilizzare un escape hatch nei seguenti scenari:

• Una Servizio AWS funzionalità è disponibile tramite CloudFormation, ma non ci sono Construct costrutti corrispondenti.

• Una Servizio AWS funzionalità è disponibile tramite CloudFormation e sono presenti Construct dei costrutti per il servizio, ma questi non espongono ancora la funzionalità. Poiché Construct i costrutti vengono sviluppati «a mano», a volte possono rimanere indietro rispetto ai costrutti delle risorse. CloudFormation

L'esempio di codice seguente mostra un caso d'uso comune per l'uso di un escape hatch. In questo esempio, la funzionalità che non è ancora implementata nel costrutto di livello superiore serve ad aggiungere httpPutResponseHopLimit per il dimensionamento automatico di LaunchConfiguration.

const launchConfig = autoscaling.onDemandASG.node.findChild("LaunchConfig") as CfnLaunchConfiguration; 
            launchConfig.metadataOptions = {
                   httpPutResponseHopLimit: autoscalingConfig.httpPutResponseHopLimit|| 2
            }

L'esempio di codice precedente illustra il seguente flusso di lavoro:

1. Definisci il AutoScalingGroup utilizzando un costrutto L2. Il costrutto L2 non supporta l'aggiornamento dihttpPutResponseHopLimit, quindi è necessario utilizzare una porta di fuga.

2. Accedi alla proprietà node.defaultChild sul costrutto AutoScalingGroup L2 ed eseguine il casting come risorsa CfnLaunchConfiguration.

3. Ora puoi impostare la proprietà launchConfig.metadataOptions su CfnLaunchConfiguration L1.

Risorse personalizzate

È possibile utilizzare risorse personalizzate per scrivere una logica di provisioning personalizzata in modelli che CloudFormation viene eseguita ogni volta che si creano, aggiornano (se si modifica la risorsa personalizzata) o si eliminano gli stack. Ad esempio, è possibile utilizzare una risorsa personalizzata se si desidera includere risorse che non sono disponibili in. AWS CDK In questo modo puoi comunque gestire tutte le risorse correlate in un singolo stack.

La creazione di una risorsa personalizzata implica la scrittura di una funzione Lambda che risponde agli eventi della risorsa e DELETE del CREATE ciclo di UPDATE vita. Se la tua risorsa personalizzata deve effettuare solo una singola API chiamata, prendi in considerazione l'utilizzo del costrutto. AwsCustomResource In questo modo è possibile eseguire SDK chiamate arbitrarie durante una CloudFormation distribuzione. Altrimenti, consigliamo di scrivere una funzione Lambda personalizzata per eseguire il lavoro necessario.

Per ulteriori informazioni sulle risorse personalizzate, consulta Risorse personalizzate nella CloudFormation documentazione. Per un esempio di come utilizzare una risorsa personalizzata, consulta l'archivio Custom Resource su GitHub.

L'esempio seguente mostra come creare una classe di risorse personalizzata per avviare una funzione Lambda e CloudFormation inviare un segnale di successo o di fallimento.

import cdk = require('aws-cdk-lib');
import customResources = require('aws-cdk-lib/custom-resources');
import lambda = require('aws-cdk-lib/aws-lambda');
import { Construct } from 'constructs';

import fs = require('fs');

export interface MyCustomResourceProps {
  /**
   * Message to echo
   */
  message: string;
}

export class MyCustomResource extends Construct {
  public readonly response: string;

  constructor(scope: Construct, id: string, props: MyCustomResourceProps) {
    super(scope, id);

    const fn = new lambda.SingletonFunction(this, 'Singleton', {
      uuid: 'f7d4f730-4ee1-11e8-9c2d-fa7ae01bbebc',
      code: new lambda.InlineCode(fs.readFileSync('custom-resource-handler.py', { encoding: 'utf-8' })),
      handler: 'index.main',
      timeout: cdk.Duration.seconds(300),
      runtime: lambda.Runtime.PYTHON_3_6,
    });

    const provider = new customResources.Provider(this, 'Provider', {
      onEventHandler: fn,
    });

    const resource = new cdk.CustomResource(this, 'Resource', {
      serviceToken: provider.serviceToken,
      properties: props,
    });

    this.response = resource.getAtt('Response').toString();
    }
}

L'esempio seguente mostra la logica principale della risorsa personalizzata.

def main(event, context):
    import logging as log
    import cfnresponse
    log.getLogger().setLevel(log.INFO)

    # This needs to change if there are to be multiple resources in the same stack
    physical_id = 'TheOnlyCustomResource'

    try:
        log.info('Input event: %s', event)

        # Check if this is a Create and we're failing Creates
        if event['RequestType'] == 'Create' and event['ResourceProperties'].get('FailCreate', False):
            raise RuntimeError('Create failure requested')

        # Do the thing
        message = event['ResourceProperties']['Message']
        attributes = {
            'Response': 'You said "%s"' % message
        }

        cfnresponse.send(event, context, cfnresponse.SUCCESS, attributes, physical_id)
    except Exception as e:
        log.exception(e)
        # cfnresponse's error message is always "see CloudWatch"
        cfnresponse.send(event, context, cfnresponse.FAILED, {}, physical_id)

L'esempio seguente mostra come lo AWS CDK stack chiama la risorsa personalizzata.

import cdk = require('aws-cdk-lib');
import { MyCustomResource } from './my-custom-resource';

/**
 * A stack that sets up MyCustomResource and shows how to get an attribute from it
 */
class MyStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const resource = new MyCustomResource(this, 'DemoResource', {
      message: 'CustomResource says hello',
    });

    // Publish the custom resource output
    new cdk.CfnOutput(this, 'ResponseMessage', {
      description: 'The message that came back from the Custom Resource',
      value: resource.response
    });
  }
}

const app = new cdk.App();
new MyStack(app, 'CustomResourceDemoStack');
app.synth();