# Transferência de dados confidenciais para um contêiner do Amazon ECS
<a name="specifying-sensitive-data"></a>

É possível transmitir dados confidenciais (p. ex., credenciais de um banco de dados) para seu contêiner com segurança. 

Os segredos, como as chaves de API e as credenciais de banco de dados, são frequentemente usados por aplicações para obter acesso a outros sistemas. Eles geralmente consistem em um nome de usuário e senha, um certificado ou uma chave de API. O acesso a esses segredos deve ser restrito a entidades principais específicas do IAM que estejam usando o IAM, e injetados em contêineres no runtime.

Os segredos podem ser injetados perfeitamente nos contêineres a partir do AWS Secrets Manager e do Systems Manager Parameter Store do Amazon EC2. Esses segredos podem ser referenciados em sua tarefa como qualquer um dos seguintes.

1. Eles são referenciadas como variáveis de ambiente que usam o parâmetro de definição de contêiner `secrets`.

1. Eles são referenciados como `secretOptions` se sua plataforma de registro em log exigir autenticação. Para obter mais informações, consulte [opções de configuração de logs](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html#API_LogConfiguration_Contents).

1. Eles são referenciados como segredos extraídos por imagens que usam o parâmetro de definição do contêiner `repositoryCredentials` se o registro de onde o contêiner está sendo retirado exigir autenticação. Use esse método ao extrair imagens da Galeria Pública do Amazon ECR. Para obter mais informações, consulte [Autenticação de registro privado para tarefas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html).

Recomendamos fazer o seguinte ao configurar o gerenciamento de segredos.

## Usar o AWS Secrets Manager ou o AWS Systems Manager Parameter Store para armazenar materiais secretos
<a name="security-secrets-management-recommendations-storing-secret-materials"></a>

Você deve armazenar com segurança chaves de API, credenciais de banco de dados e outros materiais secretos no Secrets Manager ou como um parâmetro criptografado no Systems Manager Parameter Store. Esses serviços são semelhantes porque ambos são armazenamentos gerenciados de chave-valor que usam AWS KMS para criptografar dados sigilosos. O Secrets Manager, entretanto, também inclui a capacidade de alternar segredos automaticamente, gerar segredos aleatórios e compartilhar segredos entre contas. Para utilizar esses recursos, use o Secrets Manager. Caso contrário, use parâmetros criptografados no Systems Manager Parameter Store.

**Importante**  
Se seu segredo mudar, você deverá forçar uma nova implantação ou iniciar uma nova tarefa para recuperar o valor secreto mais recente. Para saber mais, consulte os seguintes tópicos:  
Tarefas: pare a tarefa e, em seguida, inicie-a. Para obter mais informações, consulte [Interrupção de uma tarefa do Amazon ECS](standalone-task-stop.md) e [Execução de uma aplicação como uma tarefa do Amazon ECS](standalone-task-create.md).
Serviço: atualize o serviço e use a opção forçar nova implantação. Para obter mais informações, consulte [Atualizar um serviço do Amazon ECS](update-service-console-v2.md).

## Recuperação de dados de um bucket criptografado do Amazon S3
<a name="security-secrets-management-recommendations-encrypted-s3-buckets"></a>

Você deve armazenar os segredos em um bucket criptografado do Amazon S3 e usar perfis de tarefa para restringir o acesso a esses segredos. Isso evita que os valores das variáveis de ambiente vazem inadvertidamente nos logs e sejam revelados durante a execução do `docker inspect`. Ao fazer isso, sua aplicação deve ser gravada para ler o segredo do bucket do Amazon S3. Para obter instruções, consulte [Definição do comportamento padrão da criptografia do lado do servidor para buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html).

## Monte o segredo em um volume usando um contêiner auxiliar
<a name="security-secrets-management-recommendations-mount-secret-volumes"></a>

Como há um risco elevado de vazamento de dados com variáveis de ambiente, você deve usar um contêiner auxiliar que leia seus segredos do AWS Secrets Manager e os grave em um volume compartilhado. Esse contêiner pode ser executado e sair antes do contêiner da aplicação usando o [pedido de contêineres do Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html). Quando você faz isso, o contêiner da aplicação monta posteriormente o volume em que o segredo foi gravado. Assim como o método de bucket do Amazon S3, sua aplicação deve ser gravada para ler o segredo do volume compartilhado. Como o volume tem como escopo a tarefa, o volume será excluído automaticamente após a interrupção da tarefa. Para obter um exemplo, consulte o projeto [task-def.json](https://github.com/aws-samples/aws-secret-sidecar-injector/blob/master/ecs-task-def/task-def.json).

No Amazon EC2, o volume no qual o segredo é gravado pode ser criptografado com uma chave gerenciada pelo cliente AWS KMS. No AWS Fargate, o armazenamento em volume é criptografado automaticamente usando uma chave gerenciada pelo serviço. 

# Transferência de uma variável de ambiente individual para um contêiner do Amazon ECS
<a name="taskdef-envfiles"></a>

**Importante**  
Recomendamos armazenar seus dados sigilosos em segredos do AWS Secrets Manager ou parâmetros do AWS Systems Manager Parameter Store. Para obter mais informações, consulte [Transferência de dados confidenciais para um contêiner do Amazon ECS](specifying-sensitive-data.md).  
As variáveis de ambiente especificadas na definição de tarefa podem ser legíveis por todos os usuários e perfis a quem são permitidos a ação `DescribeTaskDefinition` para a definição de tarefa.

É possível transmitir variáveis de ambiente aos seus contêineres das maneiras a seguir:
+ Individualmente usando o parâmetro de definição de contêiner `environment`. Isso é mapeado para a opção `--env` para [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).
+ Em massa, usando o parâmetro de definição de contêiner `environmentFiles` para listar um ou mais arquivos que contêm as variáveis de ambiente. O arquivo deve estar hospedado no Amazon S3. Isso é mapeado para a opção `--env-file` para [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).

Veja a seguir um trecho de uma definição de tarefa que mostra como especificar variáveis de ambiente individuais.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environment": [
                {
                    "name": "variable",
                    "value": "value"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Transferência de variáveis ​​de ambiente para um contêiner do Amazon ECS
<a name="use-environment-file"></a>

**Importante**  
Recomendamos armazenar seus dados sigilosos em segredos do AWS Secrets Manager ou parâmetros do AWS Systems Manager Parameter Store. Para obter mais informações, consulte [Transferência de dados confidenciais para um contêiner do Amazon ECS](specifying-sensitive-data.md).  
Arquivos de variáveis de ambiente são objetos no Amazon S3 e todas as considerações de segurança do Amazon S3 se aplicam.   
Não é possível usar o parâmetro `environmentFiles` em contêineres do Windows e em contêineres do Windows no Fargate.

Você pode criar um arquivo de variável de ambiente e armazená-lo no Amazon S3 para passar variáveis de ambiente ao contêiner.

Ao especificar variáveis de ambiente em um arquivo, é possível injetar variáveis de ambiente em massa. Na definição do contêiner, especifique o objeto `environmentFiles` com uma lista de buckets do Amazon S3 que contêm seus arquivos de variáveis de ambiente.

O Amazon ECS não impõe um limite de tamanho às variáveis de ambiente, mas um arquivo de variáveis de ambiente grande pode ocupar o espaço em disco. Cada tarefa que usa um arquivo de variáveis de ambiente faz com que uma cópia do arquivo seja baixada no disco. O Amazon ECS remove o arquivo como parte da limpeza da tarefa.

Para obter informações sobre as variáveis de ambiente com suporte, consulte [Parâmetros avançados de definição de contêiner - Ambiente](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_environment).

Considere o seguinte ao especificar um arquivo de variáveis de ambiente em uma definição de contêiner.
+ Para tarefas do Amazon ECS no Amazon EC2, suas instâncias de contêiner exigem que o agente seja da versão `1.39.0` ou posterior para usar esse recurso. Para obter informações sobre como verificar a versão do agente e atualizar para a versão mais recente, consulte [Atualizar o agente de contêiner do Amazon ECS](ecs-agent-update.md).
+ Para tarefas do Amazon ECS no AWS Fargate, as tarefas devem usar a versão `1.4.0` ou posterior (Linux) da plataforma para usar este recurso. Para obter mais informações, consulte [Versões da plataforma do Fargate para o Amazon ECS](platform-fargate.md).

  Verifique se há suporte para a variável para a plataforma do sistema operacional. Para obter mais informações, consulte [Definições de contêiner](task_definition_parameters.md#container_definitions) e [Outros parâmetros de definição de tarefa](task_definition_parameters.md#other_task_definition_params).
+ O arquivo deve usar a extensão `.env` e a codificação UTF-8.
+ O perfil de execução da tarefa é necessário para usar esse recurso com as permissões adicionais para o Amazon S3. Isso permite que o agente de contêiner extraia o arquivo de variáveis de ambiente do Amazon S3. Para obter mais informações, consulte [Função do IAM de execução de tarefas do Amazon ECS](task_execution_IAM_role.md).
+ Há um limite de dez arquivos por definição de tarefa.
+ Cada linha em um arquivo de ambiente deve conter uma variável de ambiente no formato `VARIABLE=VALUE`. Espaços ou aspas **são** incluídos como parte dos valores para arquivos do Amazon ECS. As linhas que começam com `#` são tratadas como comentários e são ignoradas. Para obter mais informações sobre a sintaxe de arquivos de variáveis de ambiente, consulte [Definir variáveis de ambiente (-e, --env, --env-file](https://docs.docker.com/reference/cli/docker/container/run/#env)) na documentação do Docker.

  Confira a sintaxe apropriada a seguir.

  ```
  #This is a comment and will be ignored
  VARIABLE=VALUE
  ENVIRONMENT=PRODUCTION
  ```
+ Se houver variáveis de ambiente especificadas usando o parâmetro `environment` em uma definição de contêiner, elas terão precedência sobre as variáveis contidas em um arquivo de ambiente.
+ Se forem especificados vários arquivos de ambiente que contenham a mesma variável, elas serão processadas na ordem de entrada. Isso significa que o primeiro valor da variável é usado e os valores subsequentes de variáveis duplicadas são ignorados. Recomendamos usar nomes de variáveis exclusivos.
+ Se um arquivo de ambiente for especificado como substituição de contêiner, ele será utilizado. Além disso, quaisquer outros arquivos de ambiente especificados na definição de contêiner são ignorados.
+ As regras a seguir se aplicam ao Fargate:
  + O arquivo é tratado de forma semelhante a um arquivo env nativo do Docker.
  + As definições de contêiner que fazem referência a variáveis de ambiente que estão em branco e armazenadas no Amazon S3 não aparecem no contêiner.
  + Não há suporte para o tratamento de escape de shell.
  + O ponto de entrada do contêiner interpreta os valores `VARIABLE`.

## Exemplo
<a name="environment-file-example"></a>

Veja a seguir um trecho de uma definição de tarefa que mostra como especificar um arquivo de variável de ambiente.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environmentFiles": [
                {
                    "value": "arn:aws:s3:::amzn-s3-demo-bucket/envfile_object_name.env",
                    "type": "s3"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Transmissão de segredos do Secrets Manager de forma programática no Amazon ECS
<a name="secrets-app-secrets-manager"></a>

Em vez de codificar informações confidenciais em texto simples na aplicação, você pode usar o Secrets Manager para armazenar os dados confidenciais.

Recomendamos esse método de recuperação de dados confidenciais porque a aplicação recuperará automaticamente a versão mais recente do segredo se o segredo do Secrets Manager for atualizado posteriormente.

Crie um segredo no Secrets Manager. Após criar um segredo do Secrets Manager, atualize o código da aplicação para recuperá-lo.

Antes de proteger dados confidenciais no Secrets Manager, analise os seguintes fatores.
+ Somente segredos que armazenem dados de texto, criados com parâmetro `SecretString` API [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html), são compatíveis. Segredos que armazenam dados binários, criados com o parâmetro `SecretBinary` da API [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html), não são compatíveis.
+ Use os endpoints da VPC de interface para aprimorar os controles de segurança. É necessário criar endpoints da VPC de interface para o Secrets Manager. Para obter informações o endpoint da VPC, consulte [Criar endpoints da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html) no *Guia do usuário do AWS Secrets Manager*.
+ A VPC usada por sua tarefa deve usar resolução de DNS.
+ A definição de tarefa deve usar um perfil de tarefa com as permissões adicionais para o Secrets Manager. Para obter mais informações, consulte [Perfil do IAM para tarefas do Amazon ECS](task-iam-roles.md).

## Criar o segredo do Secrets Manager
<a name="secrets-app-secrets-manager-create-secret"></a>

É possível usar o console do Secrets Manager para criar um segredo para seus dados sigilosos. Para obter informações sobre como criar segredos, consulte [Criar um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) no *Guia do usuário do AWS Secrets Manager*.

## Atualizar sua aplicação para recuperar programaticamente segredos do Secrets Manager
<a name="secrets-app-secrets-manager-update-app"></a>

É possível recuperar segredos com uma chamada diretamente da sua aplicação para as APIs do Secrets Manager. Para obter informações, consulte [Retrieve secrets from AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html) no *Guia do usuário do AWS Secrets Manager*.

Para recuperar os dados confidenciais armazenados no AWS Secrets Manager, consulte [Exemplos de código para AWS Secrets Manager usando AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/secrets-manager_code_examples.html) na *Biblioteca de códigos de exemplos de códigos do AWS SDK*.

# Transmissão de segredos do Systems Manager Parameter Store de forma programática no Amazon ECS
<a name="secrets-app-ssm-paramstore"></a>

O Systems Manager Parameter Store fornece armazenamento e gerenciamento seguros de segredos. É possível armazenar dados como senhas, strings de banco de dados, IDs da instância do EC2 e IDs da AMI, e códigos de licença como valores de parâmetros, em vez de codificar essa informação em sua aplicação. É possível armazenar valores como texto sem formatação ou dados criptografados.

Recomendamos esse método de recuperação de dados confidenciais porque a aplicação recuperará automaticamente a versão mais recente se o parâmetro do Systems Manager Parameter Store for atualizado posteriormente.

Antes de proteger dados confidenciais no Systems Manager Parameter Store, analise os seguintes fatores.
+ Só há compatibilidade com segredos que armazenam dados de texto. Não há compatibilidade com segredos que armazenam dados binários.
+ Use os endpoints da VPC de interface para aprimorar os controles de segurança.
+ A VPC usada por sua tarefa deve usar resolução de DNS.
+ Para tarefas que usam o EC2, você deve usar a variável de configuração `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE=true` do agente do Amazon ECS para usar esse recurso. É possível adicioná-lo ao arquivo `/etc/ecs/ecs.config` durante a criação da instância de contêiner ou adicioná-lo a uma instância existente e reiniciar o agente do ECS. Para obter mais informações, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md).
+ A definição da tarefa deve usar um perfil de tarefa com as permissões adicionais para o Systems Manager Parameter Store. Para obter mais informações, consulte [Perfil do IAM para tarefas do Amazon ECS](task-iam-roles.md).

## Criar o parâmetro
<a name="secrets-app-ssm-paramstore-create-secret"></a>

É possível usar o console do Systems Manager para criar um parâmetro do Systems Manager Parameter Store para seus dados confidenciais. Para obter mais informações, consulte [Criar um parâmetro do Systems Manager (console)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) ou [Criar um parâmetro do Systems Manager (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html) no *Guia do usuário do AWS Systems Manager*.

## Atualizar sua aplicação para recuperar programaticamente segredos do Systems Manager Parameter Store
<a name="secrets-app-ssm-paramstore-update-app"></a>

Para recuperar os dados confidenciais armazenados no parâmetro do Systems Manager Parameter Store, consulte [Exemplos de código para Systems Manager usando AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) na *Biblioteca de códigos de exemplos de códigos do AWS SDK*.

# Transmissão de segredos do Secrets Manager por meio de variáveis ​​de ambiente do Amazon ECS
<a name="secrets-envvar-secrets-manager"></a>

Ao injetar um segredo como uma variável de ambiente, você pode especificar o conteúdo completo de um segredo, uma chave JSON específica em um segredo. Isso ajuda você a controlar os dados sigilosos expostos ao seu contêiner. Para obter mais informações sobre versionamento de segredos, consulte ‭[Qual é o conteúdo de um segredo do Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html#term_version)‭‬ no *Guia do usuário‭ do AWS Secrets Manager*.

As informações a seguir devem ser consideradas ao usar uma variável de ambiente para injetar um segredo do Secrets Manager em um contêiner.
+ Os dados sigilosos são injetados no contêiner inicialmente quando o contêiner é iniciado. Se o segredo for posteriormente atualizado ou modificado, o contêiner não receberá o valor atualizado automaticamente. Você deve executar uma nova tarefa ou se a tarefa for parte de um serviço, será possível atualizar o serviço e usar a opção **Force new deployment (Forçar nova implantação)** para forçar o serviço a iniciar uma nova tarefa.
+ Os aplicativos executados no contêiner, os logs do contêiner e as ferramentas de depuração têm acesso às variáveis ​​de ambiente.
+ Para tarefas do Amazon ECS no AWS Fargate, considere o seguinte:
  + Para injetar o conteúdo completo de um segredo como uma variável de ambiente ou em uma configuração de log, você deve usar a versão `1.3.0` ou posterior da plataforma. Para mais informações, consulte [Versões da plataforma do Fargate para o Amazon ECS](platform-fargate.md).
  + Para injetar uma chave JSON ou uma versão específica de um segredo como uma variável de ambiente ou em uma configuração de log, você deve usar a versão `1.4.0` ou posterior (Linux) ou `1.0.0` (windows) da plataforma. Para mais informações, consulte [Versões da plataforma do Fargate para o Amazon ECS](platform-fargate.md).
+ Para tarefas do Amazon ECS no EC2, é necessário considerar o seguinte:
  + Para injetar um segredo usando uma chave JSON ou uma versão específica de um segredo, sua instância de contêiner deve ter a versão `1.37.0` ou posterior do agente de contêiner. Recomendamos usar a versão mais recente do atendente de contêiner. Para obter informações sobre como verificar a versão do agente e atualizar para a versão mais recente, consulte [Atualizar o agente de contêiner do Amazon ECS](ecs-agent-update.md).

    Para injetar o conteúdo completo de um segredo como uma variável de ambiente ou injetar um segredo em uma configuração de log, sua instância de contêiner deve ter a versão `1.22.0` ou posterior do agente de contêiner.
+ Use os endpoints da VPC de interface para aprimorar os controles de segurança e se conectar ao Secrets Manager por meio de uma sub-rede privada. É necessário criar endpoints da VPC de interface para o Secrets Manager. Para obter informações o endpoint da VPC, consulte [Criar endpoints da VPC](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html) no *Guia do usuário do AWS Secrets Manager*. Para obter mais informações sobre como usar o Secrets Manager e a Amazon VPC, consulte [How to connect to Secrets Manager service within a Amazon VPC](https://aws.amazon.com/blogs//security/how-to-connect-to-aws-secrets-manager-service-within-a-virtual-private-cloud/).
+ Para tarefas do Windows configuradas para usar o driver de log `awslogs`, também é necessário definir a variável de ambiente `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` na instância de contêiner. Use a seguinte sintaxe:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```
+ A definição de tarefa deve usar um perfil de execução de tarefa com as permissões adicionais para o Secrets Manager. Para obter mais informações, consulte [Função do IAM de execução de tarefas do Amazon ECS](task_execution_IAM_role.md).

## Criar o segredo do AWS Secrets Manager
<a name="secrets-envvar-secrets-manager-create-secret"></a>

É possível usar o console do Secrets Manager para criar um segredo para seus dados sigilosos. Para obter mais informações, consulte [Criar um segredo do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) no *Guia do usuário do AWS Secrets Manager*.

## Adicionar a variável de ambiente à definição de contêiner
<a name="secrets-envvar-secrets-manager-update-container-definition"></a>

Na definição de contêiner, você pode especificar o seguinte:
+ O objeto `secrets` contendo o nome da variável de ambiente a ser definida no contêiner
+ O nome do recurso da Amazon (ARN) do segredo do Secrets Manager
+ Parâmetros adicionais que contêm os dados confidenciais a serem apresentados ao contêiner

O exemplo a seguir mostra a sintaxe completa que deve ser especificada para o segredo do Secrets Manager.

```
arn:aws:secretsmanager:region:aws_account_id:secret:secret-name:json-key:version-stage:version-id
```

A seção a seguir descreve os parâmetros adicionais. Esses parâmetros são opcionais, mas, se não usá-los, você deverá incluir os dois-pontos `:` para usar os valores padrão. Abaixo, exemplos provendo mais contexto.

`json-key`  
Especifica o nome da chave em um par de chave/ valor, com o valor que deseje definir como o valor da variável de ambiente. Somente valores formato JSON são compatíveis. Se você não especificar uma chave JSON, será usado o conteúdo completo do segredo.

`version-stage`  
Especifique o rótulo de preparação da versão do segredo que deseja usar. Se um rótulo de preparação de versão for especificado, você não poderá especificar um ID de versão. Se nenhum estágio de versão for especificado, o comportamento padrão será recuperar o segredo com o rótulo de preparação `AWSCURRENT`.  
Rótulos de preparação são usados para monitoramento de diferentes versões de um segredo quando eles forem atualizados ou alternados. Cada versão de um segredo tem um ou mais rótulos de preparação e uma ID.

`version-id`  
Especifica o identificador exclusivo da versão do segredo que você deseja usar. Se um ID de versão for especificado, você não poderá especificar um rótulo de preparação de versão. Se nenhuma ID de versão for especificada, o comportamento padrão será recuperar o segredo com o rótulo de preparação `AWSCURRENT`.  
IDs da versão são usadas para monitoramento de diferentes versões de um segredo quando atualizados ou alternados. Cada versão de um segredo tem uma ID. Para obter mais informações, consulte [Termos e conceitos principais do AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html#term_secret) no *Guia do usuário do AWS Secrets Manager*.

### Exemplo de definições de contêiner
<a name="secrets-examples"></a>

Os exemplos a seguir mostram maneiras como você pode fazer referência a segredos do Secrets Manager nas suas definições de contêiner.

**Example Referenciando um segredo completo**  
O seguinte é um trecho de definição de tarefa mostrando formato, ao fazer referência ao texto completo de um segredo Secrets Manager.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
    }]
  }]
}
```
Para acessar o valor desse segredo diretamente do contêiner, você precisaria chamar `$environment_variable_name`.

**Example referenciando segredos completos**  
Veja a seguir um trecho de uma definição de tarefa mostrando o formato ao fazer referência ao texto completo de vários segredos do Secrets Manager.  

```
{
  "containerDefinitions": [{
     "secrets": [
      {
        "name": "environment_variable_name1",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      },
      {
        "name": "environment_variable_name2",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-abcdef"
      },
      {
        "name": "environment_variable_name3",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-ABCDEF"
      }
    ]
  }]
}
```
Para acessar o valor desse segredo diretamente do contêiner, você precisaria chamar `$environment_variable_name1`, `$environment_variable_name2` e `$environment_variable_name3`.

**Example Referenciando uma chave específica dentro de um segredo**  
O seguinte é um exemplo de saída de comando [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) exibe o conteúdo de um segredo junto ao rótulo de estágio da versão e ID da versão associada a ele.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "VersionId": "871d9eca-18aa-46a9-8785-981ddEXAMPLE",
    "SecretString": "{\"username1\":\"password1\",\"username2\":\"password2\",\"username3\":\"password3\"}",
    "VersionStages": [
        "AWSCURRENT"
    ],
    "CreatedDate": 1581968848.921
}
```
Faça referência a uma chave específica de saída anterior em uma definição de contêiner especificando o nome da chave no fim do ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::"
    }]
  }]
}
```

**Example Referenciando uma versão secreta específica**  
O seguinte é um exemplo de saída de comando [describe-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html) exibindo o conteúdo não criptografado de um segredo junto aos metadados de todas as versões do segredo.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "Description": "Example of a secret containing application authorization data.",
    "RotationEnabled": false,
    "LastChangedDate": 1581968848.926,
    "LastAccessedDate": 1581897600.0,
    "Tags": [],
    "VersionIdsToStages": {
        "871d9eca-18aa-46a9-8785-981ddEXAMPLE": [
            "AWSCURRENT"
        ],
        "9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE": [
            "AWSPREVIOUS"
        ]
    }
}
```
Faça referência a um rótulo específico de preparação de versão de saída anterior em uma definição de contêiner especificando o nome da chave no fim do ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf::AWSPREVIOUS:"
    }]
  }]
}
```
Faça referência a uma ID da versão específica da saída anterior em uma definição de contêiner especificando o nome da chave no final do ARN.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

**Example Referenciando uma chave específica e um rótulo de estágio de versão de um segredo**  
O seguinte é um exemplo de como fazer referência a uma chave específica dentro de um segredo e rótulo de estágio de versão específico.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1:AWSPREVIOUS:"
    }]
  }]
}
```
Para uma chave específica e ID da versão, use a sintaxe a seguir.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

Para obter informações sobre como criar uma definição de tarefa com o segredo especificado em uma variável de ambiente, consulte [Criar uma definição de tarefa do Amazon ECS usando o console](create-task-definition.md). 

# Transmissão de parâmetros do Systems Manager por meio de variáveis ​​de ambiente do Amazon ECS
<a name="secrets-envvar-ssm-paramstore"></a>

O Amazon ECS permite que você introduza dados confidenciais em contêineres, ao armazená-los nos parâmetros do AWS Systems Manager Parameter Store e, em seguida, referenciá-los na definição do contêiner.

Considere as informações apresentadas a seguir ao usar uma variável de ambiente para introduzir um segredo do Systems Manager em um contêiner.
+ Os dados sigilosos são injetados no contêiner inicialmente quando o contêiner é iniciado. Se o segredo for posteriormente atualizado ou modificado, o contêiner não receberá o valor atualizado automaticamente. Você deve executar uma nova tarefa ou se a tarefa for parte de um serviço, será possível atualizar o serviço e usar a opção **Force new deployment (Forçar nova implantação)** para forçar o serviço a iniciar uma nova tarefa.
+ Para tarefas do Amazon ECS no AWS Fargate, o seguinte deve ser considerado:
  + Para injetar o conteúdo completo de um segredo como uma variável de ambiente ou em uma configuração de log, você deve usar a versão `1.3.0` ou posterior da plataforma. Para mais informações, consulte [Versões da plataforma do Fargate para o Amazon ECS](platform-fargate.md).
  + Para injetar uma chave JSON ou uma versão específica de um segredo como uma variável de ambiente ou em uma configuração de log, você deve usar a versão `1.4.0` ou posterior (Linux) ou `1.0.0` (windows) da plataforma. Para mais informações, consulte [Versões da plataforma do Fargate para o Amazon ECS](platform-fargate.md).
+ Para tarefas do Amazon ECS no EC2, é necessário considerar o seguinte:
  + Para injetar um segredo usando uma chave JSON ou uma versão específica de um segredo, sua instância de contêiner deve ter a versão `1.37.0` ou posterior do agente de contêiner. Recomendamos usar a versão mais recente do atendente de contêiner. Para obter informações sobre como verificar a versão do agente e atualizar para a versão mais recente, consulte [Atualizar o agente de contêiner do Amazon ECS](ecs-agent-update.md).

    Para injetar o conteúdo completo de um segredo como uma variável de ambiente ou injetar um segredo em uma configuração de log, sua instância de contêiner deve ter a versão `1.22.0` ou posterior do agente de contêiner.
+ Use os endpoints da VPC de interface para aprimorar os controles de segurança. Você deve criar os endpoints da VPC de interface para o Systems Manager. Para obter mais informações sobre o endpoint da VPC, consulte [Melhorar a segurança das instâncias do EC2 usando endpoints da VPC para o Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-create-vpc.html) no *Guia do usuário do AWS Systems Manager*.
+ A definição da tarefa deve usar um perfil de execução de tarefa com as permissões adicionais para o Systems Manager Parameter Store. Para obter mais informações, consulte [Função do IAM de execução de tarefas do Amazon ECS](task_execution_IAM_role.md).
+ Para tarefas do Windows configuradas para usar o driver de log `awslogs`, também é necessário definir a variável de ambiente `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` na instância de contêiner. Use a seguinte sintaxe:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```

## Criação do parâmetro do Systems Manager
<a name="secrets-envvar-ssm-paramstore-create-parameter"></a>

É possível usar o console do Systems Manager para criar um parâmetro do Systems Manager Parameter Store para seus dados confidenciais. Para obter mais informações, consulte [Criar um parâmetro do Systems Manager (console)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) ou [Criar um parâmetro do Systems Manager (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html) no *Guia do usuário do AWS Systems Manager*.

## Adicionar a variável de ambiente à definição de contêiner
<a name="secrets-ssm-paramstore-update-container-definition"></a>

Na definição do contêiner na definição da tarefa, especifique `secrets` com o nome da variável de ambiente a ser definida no contêiner e o ARN completo do parâmetro Systems Manager Parameter Store contendo os dados sigilosos a serem apresentados. Para obter mais informações, consulte [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

Veja a seguir um trecho de uma definição de tarefa mostrando o formato ao fazer referência a um parâmetro do Systems Manager Parameter Store. Se o parâmetro do Systems Manager Parameter Store existir na mesma região da tarefa que está sendo iniciada, será possível usar o ARN completo ou o nome do parâmetro. Se o parâmetro existir em uma região diferente, o ARN completo deverá ser especificado.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Para obter informações sobre como criar uma definição de tarefa com o segredo especificado em uma variável de ambiente, consulte [Criar uma definição de tarefa do Amazon ECS usando o console](create-task-definition.md).

## Atualizar sua aplicação para recuperar programaticamente segredos do Systems Manager Parameter Store
<a name="secrets-ssm-paramstore-update-app"></a>

Para recuperar os dados confidenciais armazenados no parâmetro do Systems Manager Parameter Store, consulte [Exemplos de código para Systems Manager usando AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) na *Biblioteca de códigos de exemplos de códigos do AWS SDK*.

# Transmissão de segredos para a configuração do registro em log do Amazon ECS
<a name="secrets-logconfig"></a>

Você pode usar o parâmetro `secretOptions` em `logConfiguration` para passar dados confidenciais usados no registro em log.

É possível armazenar o segredo no Secrets Manager ou no Systems Manager.

## Uso do Secrets Manager
<a name="secrets-logconfig-secrets-manager"></a>

Na sua definição de contêiner, ao especificar uma `logConfiguration`, você pode especificar `secretOptions` com o nome da opção de driver de log a ser definida no contêiner e o ARN completo do segredo do Secrets Manager que contém os dados sigilosos a serem apresentados ao contêiner. Para obter mais informações sobre a criação de segredos, consulte [Criar um AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

Veja a seguir um trecho de uma definição de tarefa mostrando o formato ao fazer referência a um segredo do Secrets Manager.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "splunk",
      "options": {
        "splunk-url": "https://your_splunk_instance:8088"
      },
      "secretOptions": [{
        "name": "splunk-token",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      }]
    }]
  }]
}
```

## Adicionar a variável de ambiente à definição de contêiner
<a name="secrets-envvar-ssm-paramstore-update-container-definition"></a>

Em sua definição de contêiner, especifique `secrets` com o nome da variável de ambiente a ser definida no contêiner e o ARN completo do parâmetro Systems Manager Parameter Store contendo os dados sigilosos a serem apresentados. Para obter mais informações, consulte [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

Veja a seguir um trecho de uma definição de tarefa mostrando o formato ao fazer referência a um parâmetro do Systems Manager Parameter Store. Se o parâmetro do Systems Manager Parameter Store existir na mesma região da tarefa que está sendo iniciada, será possível usar o ARN completo ou o nome do parâmetro. Se o parâmetro existir em uma região diferente, o ARN completo deverá ser especificado.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Para obter informações sobre como criar uma definição de tarefa com o segredo especificado em uma variável de ambiente, consulte [Criar uma definição de tarefa do Amazon ECS usando o console](create-task-definition.md).

## Usar o Systems Manager
<a name="secrets-logconfig-ssm-paramstore"></a>

É possível injetar dados confidenciais em uma configuração de log. Em sua definição de contêiner, ao especificar `logConfiguration`, será possível especificar `secretOptions` com o nome da opção de driver de log a ser definida no contêiner e o ARN completo do parâmetro do Systems Manager Parameter Store que contém os dados sigilosos a serem apresentados ao contêiner.

**Importante**  
Se o parâmetro do Systems Manager Parameter Store existir na mesma região da tarefa que está sendo iniciada, será possível usar o ARN completo ou o nome do parâmetro. Se o parâmetro existir em uma região diferente, o ARN completo deverá ser especificado.

Veja a seguir um trecho de uma definição de tarefa mostrando o formato ao fazer referência a um parâmetro do Systems Manager Parameter Store.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "fluentd",
      "options": {
        "tag": "fluentd demo"
      },
      "secretOptions": [{
        "name": "fluentd-address",
        "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter:/parameter_name"
      }]
    }]
  }]
}
```

# Especificar dados confidenciais usando segredos do Secrets Manager no Amazon ECS
<a name="specifying-sensitive-data-tutorial"></a>

O Amazon ECS permite a injeção de dados confidenciais nos contêineres armazenando esses dados confidenciais em segredos do AWS Secrets Manager e depois referenciando-os na definição do contêiner. Para obter mais informações, consulte [Transferência de dados confidenciais para um contêiner do Amazon ECS](specifying-sensitive-data.md).

Saiba como criar um segredo do Secrets Manager, fazer referência ao segredo em uma definição de tarefa do Amazon ECS e, em seguida, verificar se isso funcionou ao consultar a variável de ambiente dentro de um contêiner que mostra o conteúdo do segredo.

## Pré-requisitos
<a name="specifying-sensitive-data-tutorial-prereqs"></a>

Este tutorial pressupõe que os seguintes pré-requisitos foram concluídos:
+ As etapas em [Configuração para usar o Amazon ECS](get-set-up-for-amazon-ecs.md) foram concluídas.
+ Seu usuário tem as permissões do IAM necessárias para criar os recursos do Secrets Manager e do Amazon ECS.

## Etapa 1: Criar um segredo do Secrets Manager
<a name="specifying-sensitive-data-tutorial-create-secret"></a>

É possível usar o console do Secrets Manager para criar um segredo para seus dados sigilosos. Neste tutorial, vamos criar um segredo básico para armazenar um nome de usuário e uma senha para consulta posterior em um contêiner. Para obter mais informações, consulte [Criar um AWS Secrets Manager segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) no *Guia do usuário AWS Secrets Manager*.

Os **pares de chave/valor a serem armazenados nesse segredo** constituem o valor da variável de ambiente no contêiner no final do tutorial.

Salve o **Secret ARN** (ARN do segredo) para ser referenciado na política do IAM de execução de tarefa e a definição de tarefa em etapas posteriores.

## Etapa 2: adicionar as permissões de segredos ao perfil de execução da tarefa
<a name="specifying-sensitive-data-tutorial-update-iam"></a>

Para que o Amazon ECS recupere os dados sigilosos do seu segredo do Secrets Manager, é necessário ter as permissões de segredo para o perfil de execução da tarefa. Para obter mais informações, consulte [Permissões do Secrets Manager ou do Systems Manager](task_execution_IAM_role.md#task-execution-secrets).

## Etapa 3: criar uma definição de tarefa
<a name="specifying-sensitive-data-tutorial-create-taskdef"></a>

Você pode usar o console do Amazon ECS para criar uma definição de tarefa que faça referência a um segredo do Secrets Manager.

**Para criar uma definição de tarefa que especifica um segredo**

Use o console do IAM para atualizar a função de execução de tarefa com as permissões necessárias.

1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. No painel de navegação, escolha **Task definitions** (Definições de tarefa).

1. Escolha **Create new task definition** (Criar nova definição de tarefa), **Create new task definition with JSON** (Criar nova definição de tarefa com JSON).

1. Na caixa do editor JSON, e insira o texto JSON de definição de tarefa a seguir, garantindo que você especifique o ARN completo do segredo do Secrets Manager criado na etapa 1 e o perfil de execução da tarefa atualizado na etapa 2. Escolha **Salvar**.

1. 

   ```
   {
       "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "entryPoint": [
                   "sh",
                   "-c"
               ],
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ],
               "command": [
                   "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
               ],
               "cpu": 10,
               "secrets": [
                   {
                       "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:username_value",
                       "name": "username_value"
                   }
               ],
               "memory": 300,
               "image": "public.ecr.aws/docker/library/httpd:2.4",
               "essential": true,
               "name": "ecs-secrets-container"
           }
       ],
       "family": "ecs-secrets-tutorial"
   }
   ```

1. Escolha **Criar**.

## Etapa 4: criar um cluster
<a name="specifying-sensitive-data-tutorial-create-cluster"></a>

É possível usar o console do Amazon ECS para criar um cluster que contém uma instância de contêiner na qual a tarefa será executada. Se você tiver um cluster existente com pelo menos uma instância de contêiner registrada nele com os recursos disponíveis para executar uma instância da definição de tarefa criada para este tutorial, será possível pular para a próxima etapa.

Para este tutorial, vamos criar um cluster com uma instância de contêiner `t2.micro` usando a AMI do Amazon Linux 2 otimizada para o Amazon ECS.

Para obter informações sobre como criar um cluster no EC2, consulte [Criar um cluster do Amazon ECS para workloads do Amazon EC2](create-ec2-cluster-console-v2.md).

## Etapa 5: executar uma tarefa
<a name="specifying-sensitive-data-tutorial-run-task"></a>

É possível usar o console do Amazon ECS para executar uma tarefa usando a definição de tarefa que você criou. Neste tutorial, executaremos uma tarefa usando o EC2 e o cluster que criamos na etapa anterior. 

Para obter informações sobre como executar uma tarefa, consulte [Execução de uma aplicação como uma tarefa do Amazon ECS](standalone-task-create.md).

## Etapa 6: verificar
<a name="specifying-sensitive-data-tutorial-verify"></a>

É possível verificar se todas as etapas foram concluídas com êxito e a variável de ambiente foi criada corretamente em seu contêiner usando as etapas a seguir.

**Para verificar se a variável de ambiente foi criada**

1. Encontre o endereço IP público ou DNS para sua instância de contêiner.

   1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

   1. No painel de navegação, escolha **Clusters** e selecione o cluster que você criou.

   1. Escolha **Infraestrutura** e, em seguida, escolha a instância de contêiner.

   1. Registre o **IP público** ou o **DNS público** para sua instância.

1. Se você estiver usando um computador Linux ou macOS, conecte-se à sua instância com o seguinte comando, substituindo o caminho para sua chave privada e o endereço público para sua instância:

   ```
   $ ssh -i /path/to/my-key-pair.pem ec2-user@ec2-198-51-100-1.compute-1.amazonaws.com
   ```

   Para obter mais informações sobre como usar um computador com Windows, consulte [Conectar à instância do Linux usando PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-from-windows.html) no *Guia do usuário do Amazon EC2*.
**Importante**  
Para obter mais informações sobre problemas ao se conectar à instância, consulte [Solução de problemas para conectar-se à sua instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) no *Manual do usuário do Amazon EC2*.

1. Liste os contêineres em execução na instância. Anote o ID do contêiner `ecs-secrets-tutorial`.

   ```
   docker ps
   ```

1. Conecte-se ao contêiner `ecs-secrets-tutorial` usando o ID do contêiner da saída da etapa anterior.

   ```
   docker exec -it container_ID /bin/bash
   ```

1. Use o comando `echo` para imprimir o valor da variável de ambiente.

   ```
   echo $username_value
   ```

   Se o tutorial foi bem-sucedido, você deverá ver a saída a seguir.

   ```
   password_value
   ```
**nota**  
Como alternativa, você pode listar todas as variáveis de ambiente em seu contêiner usando o comando `env` (ou `printenv`).

## Etapa 7: limpar
<a name="specifying-sensitive-data-tutorial-cleanup"></a>

Ao concluir este tutorial, você deve limpar os recursos associados para evitar cobranças por recursos não utilizados.

**Limpeza dos recursos**

1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. No painel de navegação, escolha **Clusters**.

1. Na página **Clusters**, escolha o cluster.

1. Escolha **Delete Cluster**. 

1. Na caixa de confirmação, insira **excluir *nome do cluster*** e, em seguida, escolha **Excluir**.

1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, escolha **Perfis**. 

1. Procure por `ecsTaskExecutionRole` na lista de funções e selecione-a.

1. Escolha **Permissões** e escolha o **X** ao lado de **ECSSecretsTutorial**. Escolha **Remover**.

1. Abra o console do Secrets Manager em [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Selecione o segredo **username\$1value** que você criou e escolha **Actions (Ações)**, **Delete secret (Excluir segredo)**.