As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criação de imagens de contêiner para ambientes Beanstalk Cluster
Um ambiente Beanstalk Cluster executa um aplicativo a partir de uma imagem de contêiner. Assim como no Beanstalk Standard, uma versão do * aplicativo * é implantada no ambiente. Em um ambiente Beanstalk Cluster, a versão do aplicativo fornece uma imagem que o Elastic Beanstalk executa no estado em que se encontra ou uma fonte que o Elastic Beanstalk cria em uma imagem. Este tópico aborda os pré-requisitos, os caminhos de criação, o status do processamento e o comportamento de exclusão específico dos ambientes do Beanstalk Cluster. As cotas de implantação, marcação e versão funcionam da mesma forma nos dois modos, assim como os procedimentos gerais de criação e exclusão. Consulte [Gerenciar versões de aplicativos](applications-versions.md) e [Atribuir tags em versões do aplicativo](applications-versions-tagging.md).
Para uma implantação do Beanstalk Cluster, crie a versão do aplicativo com uma `ImageConfiguration` que carregue exatamente um dos dois membros. `Source`identifica uma imagem de contêiner que já foi criada e `Build` especifica como o Elastic Beanstalk cria uma imagem a partir de um pacote de origem. O Elastic Beanstalk rejeita uma `CreateApplicationVersion` solicitação que `ImageConfiguration` fornece os dois membros ou nenhum, uma solicitação que fornece ambos `ImageConfiguration.Source` e a e uma solicitação combinada `ImageConfiguration` com o `BuildConfiguration` parâmetro`SourceBundle`, que configura as versões do AWS CodeBuild aplicativo para o Beanstalk Standard. As seções a seguir descrevem cada caminho.
## Pré-requisitos
Os exemplos neste tópico usam AWS CLI o. Instale e configure-o antes de executar os comandos; eles usam a conta e a AWS região em sua AWS CLI configuração. Consulte [Antes de começar](beanstalk-cluster-getting-started.md#beanstalk-cluster-getting-started-prerequisites).
Prepare os seguintes recursos e acesse:
+ Para uma compilação de código-fonte, o `CodeBuildServiceRole` exigido por`ImageConfiguration.Build`. Essa é a função de criação de * imagem do ambiente*, que o console do Elastic Beanstalk cria como. `aws-elasticbeanstalk-eks-image-build-role` Para conhecer seus serviços e políticas confiáveis e os limites da função, consulte [Funções que você fornece](beanstalk-cluster-permissions.md#beanstalk-cluster-permissions-customer-roles) e. [Permissões para o Beanstalk Cluster](beanstalk-cluster-permissions.md)
+ Para um`ImageConfiguration.Source`, uma imagem de contêiner que já foi enviada para seu registro. A função do nó usada pelo ambiente deve ser capaz de extrair a imagem. Consulte [Funções que você fornece](beanstalk-cluster-permissions.md#beanstalk-cluster-permissions-customer-roles).
+ Para uma compilação de origem, a`SourceBundle`, um objeto Amazon S3 contendo a fonte do aplicativo. Crie o arquivo conforme descrito em[Crie um pacote de origem da aplicação Elastic Beanstalk](applications-sourcebundle.md), faça o upload para um bucket do Amazon S3 em sua conta e passe o bucket e a chave do objeto como `S3Bucket` e. `S3Key` `Process`Defina como `true` para iniciar a compilação; caso contrário, a versão permanece`UNPROCESSED`.
## Entrada de imagem do contêiner
`ImageConfiguration`Forneça um `Source` membro para uma imagem de contêiner que já foi criada e enviada para um registro. O Elastic Beanstalk executa a imagem sem uma etapa de construção. O `Source` carrega um único campo`Uri`, que aponta para a imagem. A imagem pode estar no Amazon Elastic Container Registry (Amazon ECR) ou em qualquer registro que permita uma extração não autenticada. Para uma imagem privada, use o Amazon ECR: a função de nó do ambiente é autenticada nela. Uma versão do aplicativo criada a partir de uma imagem fornecida não precisa ser compilada, então o Elastic Beanstalk a registra com o status `UNPROCESSED` e está pronta para ser implantada em um ambiente Beanstalk Cluster.
O Elastic Beanstalk registra o URI exatamente como você o fornece, independentemente de nomear uma tag ou um resumo. Uma imagem que o Elastic Beanstalk cria é registrada pelo digest.
Use essa forma quando um pipeline separado criar a imagem ou quando uma imagem produzida por uma versão anterior do aplicativo for implantada. Para que o Elastic Beanstalk crie a imagem, forneça um pacote de origem e um `Build` membro conforme descrito a seguir.
## Forneça a fonte para o Elastic Beanstalk criar
Forneça um `SourceBundle` quando o Elastic Beanstalk deve criar a imagem do contêiner a partir da fonte do aplicativo. O `SourceBundle` identifica o arquivo de origem no Amazon Simple Storage Service (Amazon S3) com dois campos e. `S3Bucket` `S3Key` Um pacote de origem também exige um `Build` membro `ImageConfiguration` Cujo especifique como o Elastic Beanstalk converte a fonte em uma imagem. `Process`Defina como `true` na `CreateApplicationVersion` solicitação para iniciar a compilação; com o AWS CLI, use`--process`. Se você omitir essa configuração, a versão do aplicativo com base na fonte permanecerá `UNPROCESSED` e a compilação não será iniciada. Quando o processamento começa, o Elastic Beanstalk cria a imagem e a envia para o Amazon Elastic Container Registry em sua conta. Para os tipos de compilação do Docker e do buildpack e suas configurações, consulte. [Configuração de compilação](#beanstalk-cluster-app-versions-buildconfig)
**nota**
No macOS, crie o arquivo de origem `zip -X -r ../my-app.zip .` de dentro do diretório de origem. O ** comando ** Comprimir do Finder adiciona entradas de `__MACOSX` metadados, e uma compilação de pacote de compilação pode falhar em uma dessas entradas com`zip: not a valid zip file`, nomeando um arquivo que você não criou.
Enquanto a compilação é executada, a versão do aplicativo informa o status`BUILDING`. Ela se move para `PROCESSED` quando a imagem é criada e enviada, ou para quando a construção não `FAILED` for bem-sucedida.
## Configuração de compilação
O `Build` membro do `ImageConfiguration` acompanha um pacote de origem e controla como o Elastic Beanstalk cria a imagem. Ele carrega os seguintes campos junto com o tipo de compilação descrito a seguir:
+ `CodeBuildServiceRole`, a função do IAM que AWS CodeBuild pressupõe a execução da compilação em sua conta. Esse campo é obrigatório para uma compilação de origem.
+ `ComputeType`, o tamanho opcional da computação de construção:`BUILD_GENERAL1_SMALL`,`BUILD_GENERAL1_MEDIUM`, ou`BUILD_GENERAL1_LARGE`. Se você omitir, o Elastic Beanstalk usará. `BUILD_GENERAL1_MEDIUM`
+ `TimeoutInMinutes`, o número opcional de minutos após os quais o Elastic Beanstalk interrompe uma compilação que não foi concluída. O valor pode ser de `5` até`480`. Se você omiti-lo, o Elastic Beanstalk usará minutos. `60`
O `Build` membro seleciona um dos dois tipos de construção por meio de seu `Type` campo, o que é obrigatório:
+ `docker`, o Elastic Beanstalk cria a imagem a partir de um Dockerfile em sua fonte. `DockerfileLocation`Defina o caminho do Dockerfile; se você o omitir, o Elastic Beanstalk usará `Dockerfile` na raiz da fonte.
+ `buildpack`, o Elastic Beanstalk cria a imagem com Cloud Native Buildpacks. `Buildpack`Defina a imagem do construtor que a compilação usa, por exemplo`paketobuildpacks/builder-jammy-base`; o Elastic Beanstalk passa o valor para a construção literalmente. O construtor é necessário para a construção de um pacote de construção. O Elastic Beanstalk não detecta um para você, e uma compilação de buildpack sem nenhum conjunto de construtores falha.
O `Architecture` campo define a arquitetura de CPU de destino da imagem, seja `amd64` ou`arm64`. Se você omiti-lo, o Elastic Beanstalk cria para. `amd64` Crie para a mesma arquitetura da `arch` configuração do ambiente, que também usa como padrão. `amd64` Uma imagem criada para uma arquitetura não é executada na outra. Em `arch`, consulte [Opções de configuração para ambientes Beanstalk Cluster](command-options-general-eks.md).
## Inspecione e monitore o status do processamento
Uma versão baseada na fonte relata `BUILDING` enquanto o Elastic Beanstalk constrói sua imagem. Implante-o somente após o relatório`PROCESSED`. Um status de `FAILED` significa que a compilação não foi bem-sucedida e que a versão não pode ser implantada. Um status de `UNPROCESSED` significa que o processamento não foi iniciado, como quando a `CreateApplicationVersion` solicitação foi omitida`Process`. Uma versão do aplicativo criada a partir de uma imagem fornecida também relata`UNPROCESSED`, mas está pronta para ser implantada porque sua imagem não requer compilação.
A descrição de uma versão do aplicativo relata seu estado de imagem como dois membros, `ImageSource` `ImageBuildConfiguration` e. Para uma versão baseada na fonte, `ImageBuildConfiguration` ecoa as configurações de compilação e `ImageSource` está ausente enquanto a versão é relatada. `BUILDING` Quando a compilação for bem-sucedida, `ImageSource` retornará o URI fixado no resumo da imagem que a compilação produziu e enviou.
Verifique o status de processamento de uma versão baseada na fonte com. `DescribeApplicationVersions` Definido `operation_start` com o carimbo de data/hora registrado imediatamente antes da `CreateApplicationVersion` solicitação; as consultas de eventos a seguir o usam para definir o escopo de eventos para a compilação.
```
$ aws elasticbeanstalk describe-application-versions \
--application-name my-app \
--version-labels v1-build \
--query 'ApplicationVersions[0].Status' \
--output text
```
Repita esse comando até que a versão alcance o status de terminal. `BUILDING`significa que a compilação ainda está em execução. Implante a versão somente após ela reportar`PROCESSED`; um status de `FAILED` ou `UNPROCESSED` significa que a versão não pode ser implantada.
Para uma versão baseada na fonte, um `PROCESSED` status e um evento de conclusão da construção da imagem confirmam que o Elastic Beanstalk criou e gravou a imagem. Recupere eventos para a versão específica para distinguir uma falha de terminal de uma compilação que ainda está em execução:
```
$ aws elasticbeanstalk describe-events \
--application-name my-app \
--version-label v1-build \
--start-time "$operation_start" \
--max-items 20
```
Se a versão chegar`FAILED`, adicione `--severity ERROR` para recuperar seus eventos de falha. Os eventos distinguem falhas como download da fonte, suposição de função, autenticação do Amazon ECR e falhas na criação ou envio de imagens:
```
$ aws elasticbeanstalk describe-events \
--application-name my-app \
--version-label v1-build \
--severity ERROR \
--start-time "$operation_start" \
--max-items 20
```
Os eventos identificam qual estágio falhou. Para ver por que a compilação em si falhou, use o `BuildArn` que uma versão baseada na fonte relata, que identifica a AWS CodeBuild execução que executou a compilação. Passe-o para o comando a seguir para obter o status da compilação e a localização de seus registros:
```
$ aws codebuild batch-get-builds \
--ids {{build-arn}} \
--query 'builds[0].{status:buildStatus,logGroup:logs.groupName,logStream:logs.streamName}'
```
A resposta também carrega um `logs.deepLink` que abre o fluxo de log da compilação no CloudWatch console da Amazon.
Corrija o local de origem, a configuração de compilação ou a configuração da função identificada pelo evento. Crie uma nova versão do aplicativo com um novo rótulo e `Process` defina-a como e`true`, em seguida, faça uma pesquisa para`PROCESSED`. Não implante uma versão em`FAILED`. O sucesso do processamento prova somente que a imagem está disponível para a versão do aplicativo; ele não verifica a implantação de um ambiente.
## O aplicativo de amostra
Uma versão do aplicativo é opcional ao criar um ambiente Beanstalk Cluster. Quando `CreateEnvironment` é chamado sem um rótulo de versão (ou com um em branco), o Elastic Beanstalk implanta um aplicativo de amostra para fornecer um ambiente de execução. O Elastic Beanstalk respalda a amostra com uma imagem de contêiner pré-criada, portanto, a implantação não exige nenhuma etapa de construção. O aplicativo de amostra não pode ser selecionado ou configurado como um aplicativo do cliente; o Elastic Beanstalk o implanta quando nenhum rótulo de versão é especificado. Para implantar um aplicativo, crie uma versão do aplicativo conforme descrito neste tópico e passe seu rótulo de versão para`CreateEnvironment`. Para criação de ambiente, consulte[Começando com o Beanstalk Cluster](beanstalk-cluster-getting-started.md).
## Exemplos
A `CreateApplicationVersion` solicitação a seguir fornece uma imagem de contêiner existente. O Elastic Beanstalk executa a imagem no estado em que se encontra, sem compilação.
```
aws elasticbeanstalk create-application-version \
--application-name my-app \
--version-label v1-image \
--image-configuration Source={Uri=111122223333.dkr.ecr.us-east-1.amazonaws.com/my-app:v1}
```
Em vez disso, a solicitação a seguir fornece um pacote de origem no Amazon S3 e uma configuração de compilação que cria a imagem a partir de um Dockerfile para a arquitetura. `arm64` Para executar essa imagem, defina a `arch` opção do ambiente `arm64` como também.
```
operation_start=$(date -u +%Y-%m-%dT%H:%M:%SZ)
aws elasticbeanstalk create-application-version \
--application-name my-app \
--version-label v1-build \
--process \
--source-bundle S3Bucket=my-source-bucket,S3Key=my-app/v1.zip \
--image-configuration '{
"Build": {
"Type": "docker",
"DockerfileLocation": "Dockerfile",
"Architecture": "arm64",
"CodeBuildServiceRole": "arn:aws:iam::111122223333:role/my-build-role",
"ComputeType": "BUILD_GENERAL1_SMALL",
"TimeoutInMinutes": 30
}
}'
```
A solicitação a seguir cria a imagem com Cloud Native Buildpacks em vez de um Dockerfile. A fonte não precisa de Dockerfile e o construtor determina como a imagem é montada. A solicitação é omitida`Architecture`, então o Elastic Beanstalk cria para. `amd64`
```
operation_start=$(date -u +%Y-%m-%dT%H:%M:%SZ)
aws elasticbeanstalk create-application-version \
--application-name my-app \
--version-label v1-buildpack \
--process \
--source-bundle S3Bucket=my-source-bucket,S3Key=my-app/v1.zip \
--image-configuration '{
"Build": {
"Type": "buildpack",
"Buildpack": "paketobuildpacks/builder-jammy-base",
"CodeBuildServiceRole": "arn:aws:iam::111122223333:role/my-build-role"
}
}'
```
Depois que a compilação do pacote de origem chegar`PROCESSED`, implante qualquer uma dessas versões em um ambiente Beanstalk Cluster passando seu rótulo de versão para `CreateEnvironment` ou`UpdateEnvironment`, como para uma versão do aplicativo Beanstalk Standard. Para configurar o ambiente que o executa, consulte[Configurar ambientes do Elastic Beanstalk](customize-containers.md).
## Excluir e recuperar versões do aplicativo
As políticas de ciclo de vida da versão do aplicativo não excluem as versões do aplicativo Beanstalk Cluster. Use `DeleteApplicationVersion` para remover um registro de versão do aplicativo. O Elastic Beanstalk rejeita a solicitação enquanto a versão está disponível`BUILDING`; aguarde o status de processamento do terminal antes de excluí-la.
Para uma versão do aplicativo Beanstalk Cluster, a `DeleteSourceBundle` opção não exclui o pacote de origem do Amazon S3. Source-object a retenção é gerenciada separadamente.
`DeleteApplicationVersion`remove o registro da versão do aplicativo Elastic Beanstalk. Ele não exclui uma imagem fornecida`ImageConfiguration.Source`, uma imagem produzida por uma compilação de origem ou o repositório Amazon ECR que contém a imagem. Você gerencia a retenção de uma imagem que você forneceu. Quando o Elastic Beanstalk cria um repositório Amazon ECR para compilações de origem, ele aplica uma política de ciclo de vida a esse repositório; a exclusão de uma versão do aplicativo não realiza a limpeza imediata da imagem ou do repositório.
Uma versão baseada na fonte no `FAILED` estado não pode ser implantada. Corrija a configuração de origem ou compilação e chame `CreateApplicationVersion` com um novo rótulo de versão e `Process` defina como`true`. Para reutilizar o rótulo da versão que falhou, primeiro exclua o registro da versão depois que ele sair e, em seguida`BUILDING`, crie a versão corrigida.