Onde você pode especificar ambientes de Precedência ambiental com o AWS CDK Quando especificar ambientes Como especificar ambientes com o AWS CDK Considerações ao configurar ambientes com o AWS CDK Exemplos

Configure ambientes para usar com o AWS CDK

Você pode configurar AWS ambientes de várias maneiras de usar com AWS Cloud Development Kit (AWS CDK) o. O melhor método de gerenciamento de AWS ambientes varia de acordo com suas necessidades específicas.

Cada pilha de CDK em seu aplicativo deve eventualmente ser associada a um ambiente para determinar onde a pilha será implantada.

Para uma introdução aos AWS ambientes, consulteAmbientes do.

Tópicos

Onde você pode especificar ambientes de
Precedência ambiental com o AWS CDK
Quando especificar ambientes
Como especificar ambientes com o AWS CDK
Considerações ao configurar ambientes com o AWS CDK
Exemplos

Onde você pode especificar ambientes de

Você pode especificar ambientes em credenciais e arquivos de configuração ou usando a env propriedade da Stack construção da Construct Library. AWS

Credenciais e arquivos de configuração

Você pode usar o AWS Command Line Interface (AWS CLI) para criar credentials config arquivos que armazenam, organizam e gerenciam as informações do seu AWS ambiente. Para saber mais sobre esses arquivos, consulte Configurações e configurações do arquivo de credenciais no Guia do AWS Command Line Interface usuário.

Os valores armazenados nesses arquivos são organizados por perfis. A forma como você nomeia seus perfis e os pares de valores-chave nesses arquivos variará de acordo com seu método de configuração do acesso programático. Para saber mais sobre os diferentes métodos, consulteConfigure as credenciais de segurança para o AWS CDKCLI.

Em geral, o AWS CDK resolve as Conta da AWS informações do seu credentials arquivo e Região da AWS as informações do seu config arquivo.

Depois de configurar seus config arquivos credentials e, você pode especificar o ambiente a ser usado com as variáveis de ambiente AWS CDK CLI e por meio delas.

propriedade env da construção Stack

Você pode especificar o ambiente para cada pilha usando a env propriedade da Stack construção. Essa propriedade define uma conta e uma região a serem usadas. Você pode passar valores codificados para essa propriedade ou passar variáveis de ambiente que são oferecidas pelo CDK.

Para passar variáveis de ambiente, use AWS_DEFAULT_ACCOUNT as variáveis de AWS_DEFAULT_REGION ambiente e. Essas variáveis de ambiente podem passar valores de seus config arquivos credentials e. Você também pode usar a lógica em seu código CDK para determinar os valores dessas variáveis de ambiente.

Precedência ambiental com o AWS CDK

Se você usa vários métodos de especificação de ambientes, AWS CDK segue a seguinte precedência:

Valores codificados especificados com a env propriedade da construção. Stack
AWS_DEFAULT_ACCOUNTe variáveis de AWS_DEFAULT_REGION ambiente especificadas com a env propriedade da Stack construção.
Informações do ambiente associadas ao perfil de seus config arquivos credentials e passadas para o CDK CLI usando a --profile opção.
O default perfil do seu credentials e config dos arquivos.

Quando especificar ambientes

Ao desenvolver com o CDK, você começa definindo pilhas de CDK, que contêm construções que representam recursos. AWS Em seguida, você sintetiza cada pilha de CDK em um modelo. AWS CloudFormation Em seguida, você implanta o CloudFormation modelo em seu ambiente. A forma como você especifica os ambientes determina quando as informações do seu ambiente são aplicadas e pode afetar o comportamento e os resultados do CDK.

Especifique ambientes na síntese do modelo

Quando você especifica as informações do ambiente usando a env propriedade da Stack construção, as informações do ambiente são aplicadas na síntese do modelo. Executando cdk synth ou cdk deploy produzindo um modelo específico do ambiente CloudFormation .

Se você usar variáveis de ambiente na env propriedade, deverá usar a --profile opção com CLI comandos do CDK para transmitir o perfil contendo as informações do ambiente a partir de suas credenciais e arquivos de configuração. Essas informações serão então aplicadas na síntese do modelo para produzir um modelo específico do ambiente.

As informações do ambiente no CloudFormation modelo têm precedência sobre outros métodos. Por exemplo, se você fornecer um ambiente diferente comcdk deploy --profile profile, o perfil será ignorado.

Ao fornecer informações sobre o ambiente dessa forma, você pode usar código e lógica dependentes do ambiente em seu aplicativo CDK. Isso também significa que o modelo sintetizado pode ser diferente, com base na máquina, no usuário ou na sessão em que está sintetizado. Essa abordagem geralmente é aceitável ou desejável durante o desenvolvimento, mas não é recomendada para uso em produção.

Especifique ambientes na implantação da pilha

Se você não especificar um ambiente usando a env propriedade da Stack construção, o CDK CLI produzirá um modelo independente do ambiente na síntese CloudFormation . Em seguida, você pode especificar o ambiente no qual implantar usandocdk deploy --profile profile.

Se você não especificar um perfil ao implantar um modelo independente do ambiente, o CDK CLI tentará usar os valores do ambiente do seu default perfil e dos arquivos na implantação. credentials config

Se as informações do ambiente não estiverem disponíveis na implantação, AWS CloudFormation tentará resolver as informações do ambiente na implantação por meio de atributos relacionados ao ambientestack.account, comostack.region, e. stack.availabilityZones

Para pilhas independentes do ambiente, as construções dentro da pilha não podem usar informações do ambiente e você não pode usar a lógica que exija informações do ambiente. Por exemplo, você não pode escrever código como if (stack.region ==== 'us-east-1') ou usar métodos de construção que exijam informações do ambiente, comoVpc.fromLookup. Para usar esses recursos, você deve especificar um ambiente com a env propriedade.

Para pilhas independentes do ambiente, qualquer construção que use zonas de disponibilidade verá duas zonas de disponibilidade, permitindo que a pilha seja implantada em qualquer região.

Como especificar ambientes com o AWS CDK

Especifique ambientes codificados para cada pilha

Use a env propriedade da Stack construção para especificar valores de AWS ambiente para sua pilha. Veja um exemplo a seguir:

TypeScript


const envEU  = { account: '2383838383', region: 'eu-west-1' };
const envUSA = { account: '8373873873', region: 'us-west-2' };

new MyFirstStack(app, 'first-stack-us', { env: envUSA });
new MyFirstStack(app, 'first-stack-eu', { env: envEU });

JavaScript


const envEU  = { account: '2383838383', region: 'eu-west-1' };
const envUSA = { account: '8373873873', region: 'us-west-2' };

new MyFirstStack(app, 'first-stack-us', { env: envUSA });
new MyFirstStack(app, 'first-stack-eu', { env: envEU });

Python


env_EU = cdk.Environment(account="8373873873", region="eu-west-1")
env_USA = cdk.Environment(account="2383838383", region="us-west-2")

MyFirstStack(app, "first-stack-us", env=env_USA)
MyFirstStack(app, "first-stack-eu", env=env_EU)

Java


public class MyApp {

    // Helper method to build an environment
    static Environment makeEnv(String account, String region) {
        return Environment.builder()
                .account(account)
                .region(region)
                .build();
    }

    public static void main(final String argv[]) {
        App app = new App();

        Environment envEU = makeEnv("8373873873", "eu-west-1");
        Environment envUSA = makeEnv("2383838383", "us-west-2");
        
        new MyFirstStack(app, "first-stack-us", StackProps.builder()
                .env(envUSA).build());
        new MyFirstStack(app, "first-stack-eu", StackProps.builder()
                .env(envEU).build());
 
        app.synth();
    }
}

C#


Amazon.CDK.Environment makeEnv(string account, string region)
{
    return new Amazon.CDK.Environment
    {
        Account = account,
        Region = region
    };
}

var envEU = makeEnv(account: "8373873873", region: "eu-west-1");
var envUSA = makeEnv(account: "2383838383", region: "us-west-2");

new MyFirstStack(app, "first-stack-us", new StackProps { Env=envUSA });
new MyFirstStack(app, "first-stack-eu", new StackProps { Env=envEU });

Go


env_EU := awscdk.Environment{
	Account: jsii.String("8373873873"),
	Region:  jsii.String("eu-west-1"),
}

env_USA := awscdk.Environment{
	Account: jsii.String("2383838383"),
	Region:  jsii.String("us-west-2"),
}

MyFirstStack(app, "first-stack-us", &awscdk.StackProps{
	Env: &env_USA,
})

MyFirstStack(app, "first-stack-eu", &awscdk.StackProps{
	Env: &env_EU,
})

Recomendamos essa abordagem para ambientes de produção. Ao especificar explicitamente o ambiente dessa forma, você pode garantir que a pilha seja sempre implantada no ambiente específico.

Especifique ambientes usando variáveis de ambiente

O AWS CDK fornece duas variáveis de ambiente que você pode usar em seu código CDK: CDK_DEFAULT_ACCOUNT e. CDK_DEFAULT_REGION Ao usar essas variáveis de ambiente na env propriedade de sua instância de pilha, você pode transmitir informações de ambiente de suas credenciais e arquivos de configuração usando a opção CLI --profile CDK.

Veja a seguir um exemplo de como especificar essas variáveis de ambiente:

TypeScript

Acesse variáveis de ambiente por meio do process objeto do Node.

nota

Você precisa do DefinitelyTyped módulo para usar process em TypeScript. cdk initinstala esse módulo para você. No entanto, você deve instalar esse módulo manualmente se estiver trabalhando com um projeto criado antes de ser adicionado ou se você não configurou seu projeto usandocdk init.


npm install @types/node


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEFAULT_REGION 
}});

JavaScript

Acesse variáveis de ambiente por meio do process objeto do Node.


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEFAULT_REGION 
}});

Python

Use o environ dicionário do os módulo para acessar as variáveis de ambiente.


import os
MyDevStack(app, "dev", env=cdk.Environment(
    account=os.environ["CDK_DEFAULT_ACCOUNT"],
    region=os.environ["CDK_DEFAULT_REGION"]))

Java

Use System.getenv() para obter o valor de uma variável de ambiente.


public class MyApp {

    // Helper method to build an environment
    static Environment makeEnv(String account, String region) {
        account = (account == null) ? System.getenv("CDK_DEFAULT_ACCOUNT") : account;
        region = (region == null) ? System.getenv("CDK_DEFAULT_REGION") : region;

        return Environment.builder()
                .account(account)
                .region(region)
                .build();
    }

    public static void main(final String argv[]) {
        App app = new App();

        Environment envEU = makeEnv(null, null);
        Environment envUSA = makeEnv(null, null);
        
        new MyDevStack(app, "first-stack-us", StackProps.builder()
                .env(envUSA).build());
        new MyDevStack(app, "first-stack-eu", StackProps.builder()
                .env(envEU).build());
 
        app.synth();
    }
}

C#

Use System.Environment.GetEnvironmentVariable() para obter o valor de uma variável de ambiente.


Amazon.CDK.Environment makeEnv(string account=null, string region=null)
{
    return new Amazon.CDK.Environment
    {
        Account = account ?? System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT"),
        Region = region ?? System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION")
    };
}

new MyDevStack(app, "dev", new StackProps { Env = makeEnv() });

Go


import "os"

MyDevStack(app, "dev", &awscdk.StackProps{
	Env: &awscdk.Environment{
		Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
		Region:  jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
    },
})

Ao especificar ambientes usando variáveis de ambiente, você pode ter a mesma pilha de CDK sintetizada em modelos para AWS CloudFormation ambientes diferentes. Isso significa que você pode implantar a mesma pilha de CDK em AWS ambientes diferentes sem precisar modificar seu código de CDK. Você só precisa especificar o perfil a ser usado durante a execuçãocdk synth.

Essa abordagem é ótima para ambientes de desenvolvimento ao implantar a mesma pilha em ambientes diferentes. No entanto, não recomendamos essa abordagem para ambientes de produção, pois o mesmo código CDK pode sintetizar modelos diferentes, dependendo da máquina, do usuário ou da sessão em que está sintetizado.

Especifique ambientes a partir de suas credenciais e arquivos de configuração com o CDK CLI

Ao implantar um modelo independente do ambiente, use a --profile opção com qualquer CLI comando do CDK para especificar o perfil a ser usado. Veja a seguir um exemplo que implanta uma pilha de CDK chamada myStack usando o prod perfil definido nos credentials arquivos and: config


$ cdk deploy myStack --profile prod

Para obter mais informações sobre a --profile opção, junto com outros CLI comandos e opções do CDK, consulteAWS CDKCLIReferência de comando.

Considerações ao configurar ambientes com o AWS CDK

Os serviços que você define usando construções em suas pilhas devem oferecer suporte à região na qual você está implantando. Para obter uma lista de suporte Serviços da AWS por região, consulte AWS Serviços por região.

Você deve ter credenciais válidas AWS Identity and Access Management (IAM) para realizar implantações de pilha com o AWS CDK em seus ambientes especificados.

Exemplos

Sintetize um modelo independente do ambiente a partir de uma pilha de CloudFormation CDK

Neste exemplo, criamos um CloudFormation modelo independente do ambiente a partir da nossa pilha de CDK. Em seguida, podemos implantar esse modelo em qualquer ambiente.

Veja a seguir nosso exemplo de pilha de CDK. Essa pilha define um bucket do Amazon S3 e CloudFormation uma saída de pilha para a região do bucket. Para este exemplo, não env está definido:

TypeScript


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

    // Create the S3 bucket
    const bucket = new s3.Bucket(this, 'myBucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
    
    // Create an output for the bucket's Region
    new cdk.CfnOutput(this, 'BucketRegion', {
      value: bucket.env.region,
    });
  }
}

JavaScript


class CdkAppStack extends cdk.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Create the S3 bucket
    const bucket = new s3.Bucket(this, 'myBucket', {
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });
    
    // Create an output for the bucket's Region
    new cdk.CfnOutput(this, 'BucketRegion', {
      value: bucket.env.region,
    });
  }
}

Python


class CdkAppStack(cdk.Stack):

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

        # Create the S3 bucket
        bucket = s3.Bucket(self, 'myBucket',
            removal_policy=cdk.RemovalPolicy.DESTROY
        )
        
        # Create an output for the bucket's Region
        cdk.CfnOutput(self, 'BucketRegion',
            value=bucket.env.region
        )

Java


public class CdkAppStack extends Stack {

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

        // Create the S3 bucket
        Bucket bucket = Bucket.Builder.create(this, "myBucket")
            .removalPolicy(RemovalPolicy.DESTROY)
            .build();
        
        // Create an output for the bucket's Region
        CfnOutput.Builder.create(this, "BucketRegion")
            .value(this.getRegion())
            .build();
    }
}

C#


namespace MyCdkApp
{
    public class CdkAppStack : Stack
    {
        public CdkAppStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            // Create the S3 bucket
            var bucket = new Bucket(this, "myBucket", new BucketProps
            {
                RemovalPolicy = RemovalPolicy.DESTROY
            });
            
            // Create an output for the bucket's Region
            new CfnOutput(this, "BucketRegion", new CfnOutputProps
            {
                Value = this.Region
            });
        }
    }
}

Go


func NewCdkAppStack(scope constructs.Construct, id string, props *CdkAppStackProps) awscdk.Stack {
	stack := awscdk.NewStack(scope, &id, &props.StackProps)

	// Create the S3 bucket
	bucket := awss3.NewBucket(stack, jsii.String("myBucket"), &awss3.BucketProps{
		RemovalPolicy: awscdk.RemovalPolicy_DESTROY,
	})
	
	// Create an output for the bucket's Region
	awscdk.NewCfnOutput(stack, jsii.String("BucketRegion"), &awscdk.CfnOutputProps{
		Value: stack.Region(),
	})

	return stack
}

Quando executamoscdk synth, o CDK CLI produz um CloudFormation modelo com o pseudoparâmetro AWS::Region como valor de saída para a região do bucket. Esse parâmetro será resolvido na implantação:


Outputs:
  BucketRegion:
    Value:
      Ref: AWS::Region

Para implantar essa pilha em um ambiente especificado no dev perfil de nossas credenciais e arquivos de configuração, executamos o seguinte:


$ cdk deploy CdkAppStack --profile dev

Se não especificarmos um perfil, o CDK CLI tentará usar as informações do ambiente do default perfil em nossas credenciais e arquivos de configuração.

Use a lógica para determinar as informações do ambiente na síntese do modelo

Neste exemplo, configuramos a env propriedade da nossa stack instância para usar uma expressão válida. Especificamos duas variáveis de ambiente adicionais CDK_DEPLOY_ACCOUNT CDK_DEPLOY_REGION e. Essas variáveis de ambiente podem substituir os padrões no momento da síntese, se existirem:

TypeScript


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEPLOY_ACCOUNT || process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEPLOY_REGION || process.env.CDK_DEFAULT_REGION 
}});

JavaScript


new MyDevStack(app, 'dev', { 
  env: { 
    account: process.env.CDK_DEPLOY_ACCOUNT || process.env.CDK_DEFAULT_ACCOUNT, 
    region: process.env.CDK_DEPLOY_REGION || process.env.CDK_DEFAULT_REGION 
}});

Python


MyDevStack(app, "dev", env=cdk.Environment(
    account=os.environ.get("CDK_DEPLOY_ACCOUNT", os.environ["CDK_DEFAULT_ACCOUNT"]),
    region=os.environ.get("CDK_DEPLOY_REGION", os.environ["CDK_DEFAULT_REGION"])

Java


public class MyApp {

    // Helper method to build an environment
    static Environment makeEnv(String account, String region) {
        account = (account == null) ? System.getenv("CDK_DEPLOY_ACCOUNT") : account;
        region = (region == null) ? System.getenv("CDK_DEPLOY_REGION") : region;
        account = (account == null) ? System.getenv("CDK_DEFAULT_ACCOUNT") : account;
        region = (region == null) ? System.getenv("CDK_DEFAULT_REGION") : region;

        return Environment.builder()
                .account(account)
                .region(region)
                .build();
    }

    public static void main(final String argv[]) {
        App app = new App();

        Environment envEU = makeEnv(null, null);
        Environment envUSA = makeEnv(null, null);
        
        new MyDevStack(app, "first-stack-us", StackProps.builder()
                .env(envUSA).build());
        new MyDevStack(app, "first-stack-eu", StackProps.builder()
                .env(envEU).build());
 
        app.synth();
    }
}

C#


Amazon.CDK.Environment makeEnv(string account=null, string region=null)
{
    return new Amazon.CDK.Environment
    {
        Account = account ??
            System.Environment.GetEnvironmentVariable("CDK_DEPLOY_ACCOUNT") ??
            System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT"),
        Region = region ?? 
            System.Environment.GetEnvironmentVariable("CDK_DEPLOY_REGION") ??
            System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION")
    };
}

new MyDevStack(app, "dev", new StackProps { Env = makeEnv() });

Go


var account, region string
var b bool

if account, b = os.LookupEnv("CDK_DEPLOY_ACCOUNT"); !b || len(account) == 0 {
	account = os.Getenv("CDK_DEFAULT_ACCOUNT")
}
if region, b = os.LookupEnv("CDK_DEPLOY_REGION"); !b || len(region) == 0 {
	region = os.Getenv("CDK_DEFAULT_REGION")
}

MyDevStack(app, "dev", &awscdk.StackProps{
	Env: &awscdk.Environment{
		Account: &account,
		Region:  &region,
	},
})

Com o ambiente da nossa pilha declarado dessa forma, podemos escrever um script curto ou arquivo em lote, definir variáveis a partir dos argumentos da linha de comando e, em seguida, chamarcdk deploy. Veja um exemplo a seguir. Todos os argumentos além dos dois primeiros são passados cdk deploy para especificar as opções ou argumentos da linha de comando:

Em seguida, podemos escrever scripts adicionais que usam o cdk-deploy-to script para implantar em ambientes específicos. Veja um exemplo a seguir:

Veja a seguir um exemplo que usa o cdk-deploy-to script para implantar em vários ambientes. Se a primeira implantação falhar, o processo será interrompido:

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Exemplo: use o AWS CLI para configurar credenciais de segurança

Inicialize seu ambiente