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á.
# Trabalhando com instâncias para CodeDeploy
CodeDeploy oferece suporte a implantações em instâncias que executam Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) e Windows Server.
Você pode usar CodeDeploy para implantar tanto em instâncias do Amazon EC2 quanto em instâncias locais. Uma instância local é qualquer dispositivo físico que não seja uma instância do Amazon EC2 que possa executar CodeDeploy o agente e se conectar a endpoints de serviço AWS público. Você pode usar CodeDeploy para implantar simultaneamente um aplicativo nas instâncias do Amazon EC2 na nuvem e no desktop PCs em seu escritório ou em servidores em seu próprio data center.
## Comparação de instâncias do Amazon EC2 com instâncias on-premises
A tabela a seguir compara instâncias do Amazon EC2 e instâncias on-premises:
| **Sujeito** | **Instâncias do Amazon EC2** | **Instâncias on-premises** |
| --- | --- | --- |
| Exige que você instale e execute uma versão do CodeDeploy agente compatível com o sistema operacional em execução na instância. | Sim | Sim |
| Requer que a instância seja capaz de se conectar ao serviço do CodeDeploy. | Sim | Sim |
| Requer que um perfil de instância do IAM seja anexado à instância. O perfil da instância do IAM precisa ter permissões para participar das CodeDeploy implantações. Para mais informações, consulte [Etapa 4: criar um perfil de instância do IAM para as suas instâncias do Amazon EC2](getting-started-create-iam-instance-profile.md). | Sim | Não |
| Requer que você siga um destes procedimentos para autenticar e registrar instâncias: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/instances.html) | Não | Sim |
| Exige que você registre cada instância CodeDeploy antes de poder implantá-la. | Não | Sim |
| Exige que você marque cada instância antes de CodeDeploy poder implantá-la. | Sim | Sim |
| Pode participar dos cenários Amazon EC2 Auto Scaling e Elastic Load Balancing como parte das implantações. CodeDeploy | Sim | Não |
| Pode ser implantado a partir de GitHub buckets e repositórios do Amazon S3. | Sim | Sim |
| Pode dar suporte a gatilhos que solicitam o envio de notificações por SMS ou e-mail quando eventos específicos ocorrerem em implementações ou instâncias. | Sim | Sim |
| Está sujeito a cobrança por implantações associadas. | Não | Sim |
## Tarefas de instância para CodeDeploy
Para iniciar ou configurar instâncias para uso em implantações, escolha uma das seguintes instruções:
| | |
| --- |--- |
| Quero iniciar uma nova instância do Amazon EC2 para Amazon Linux ou Windows Server. | Para iniciar a instância do Amazon EC2 com o mínimo de esforço, consulte [Crie uma instância do Amazon EC2 para CodeDeploy (modelo)CloudFormation](instances-ec2-create-cloudformation-template.md). Para iniciar a instância do Amazon EC2 principalmente por sua conta, consulte [Crie uma instância do Amazon EC2 para CodeDeploy (AWS CLI ou console do Amazon EC2)](instances-ec2-create.md). |
| Quero iniciar uma nova instância do Amazon EC2 para Ubuntu Server ou RHEL. | Consulte [Crie uma instância do Amazon EC2 para CodeDeploy (AWS CLI ou console do Amazon EC2)](instances-ec2-create.md). |
| Quero configurar uma instância do Amazon EC2 para Amazon Linux, Windows Server, Ubuntu Server ou RHEL. | Consulte [Configurar uma instância do Amazon EC2 para trabalhar com CodeDeploy](instances-ec2-configure.md). |
| Quero configurar uma instância on-premises para Windows Server, Ubuntu Server ou RHEL (dispositivos físicos que não são instâncias do Amazon EC2). | Consulte [Trabalhando com instâncias locais para CodeDeploy](instances-on-premises.md). |
| Quero CodeDeploy provisionar uma frota substituta de instâncias durante uma blue/green implantação. | Consulte [Trabalhando com implantações em CodeDeploy](deployments.md). |
Para preparar instâncias do Amazon EC2 em grupos do Amazon EC2 Auto Scaling, você deve seguir algumas etapas adicionais. Para obter mais informações, consulte [Integração CodeDeploy com o Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
**Tópicos**
+ [Tagging Instances for Deployments](instances-tagging.md)
+ [Working with Amazon EC2 Instances](instances-ec2.md)
+ [Working with On-Premises Instances](instances-on-premises.md)
+ [View Instance Details](instances-view-details.md)
+ [Instance Health](instances-health.md)
# Marcar instâncias para grupos de implantação em CodeDeploy
Para ajudar a gerenciar as instâncias do Amazon EC2 e instâncias on-premises, você pode usar tags para atribuir seus próprios metadados a cada recurso. As tags permitem categorizar suas instâncias de diferentes formas (como por finalidade, por proprietário ou por ambiente). Isso é útil quando você tem várias instâncias. Você pode identificar rapidamente uma instância ou grupo de instâncias com base nas tags que você tiver atribuído a elas. Cada tag consiste de uma chave e um valor opcional, que podem ser definidos. Para obter mais informações, consulte [Marcar recursos do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html).
Para especificar quais instâncias estão incluídas em um grupo de CodeDeploy implantação, você especifica tags em um ou mais *grupos de tags*. As instâncias que atendem aos critérios de tag são aquelas nas quais a revisão de aplicativo mais recente esteja instalada quando uma implantação para o grupo de implementação for criado
**nota**
Você também pode incluir grupos do Amazon EC2 Auto Scaling em grupos de implantação, mas eles são identificados por seus nomes em vez de tags aplicadas a instâncias. Para mais informações, consulte [Integração CodeDeploy com o Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
Os critérios para instâncias em um grupo de implementação podem ser tão simples quanto uma única tag em um único grupo de tags. Pode ser tão complexo como 10 tags, cada uma em um máximo de três grupos de tags.
Se você usar um grupo de tag única, qualquer instância identificada por pelo menos uma tag no grupo é incluída no grupo de implementação. Se você usar grupos de várias tags, apenas as instâncias que são identificadas por pelo menos uma tag em *cada* um dos grupos de tags serão incluídas.
Os exemplos a seguir ilustram como tags e grupos de tags podem ser usados para selecionar as instâncias de um grupo de implantação.
**Topics**
+ [Exemplo 1: Grupo de tag única, tag única](#instances-tagging-example-1)
+ [Exemplo 2: Grupo de tag única, várias tags](#instances-tagging-example-2)
+ [Exemplo 3: Grupos de várias tags, tags únicas](#instances-tagging-example-3)
+ [Exemplo 4: Grupos de várias tags, várias tags](#instances-tagging-example-4)
## Exemplo 1: Grupo de tag única, tag única
Você pode especificar uma tag única em um grupo de tag única:
**Grupo de tags 1**
| Chave | Valor |
| --- | --- |
| Nome | AppVersion-ABC |
Cada instância marcada com `Name=AppVersion-ABC` faz parte do grupo de implantação, mesmo se tiver outras tags aplicadas.
CodeDeploy visualização da configuração do console:
![\[O CodeDeploy console mostrando um grupo de tags com uma tag.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/TaggingExample1-polaris.png)
Estrutura do JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
]
]
},
```
## Exemplo 2: Grupo de tag única, várias tags
Você também pode especificar várias tags em um grupo de tag única:
**Grupo de tags 1**
| Chave | Valor |
| --- | --- |
| Região | Norte |
| Região | Sul |
| Região | Leste |
Uma instância marcada com qualquer dessas três tags faz parte do grupo de implantação, mesmo se tiver outras tags aplicadas. Se, por exemplo, você tiver outras instâncias com `Region=West`, elas não seriam incluídas no grupo de implantação.
CodeDeploy visualização da configuração do console:
![\[O CodeDeploy console mostrando um grupo de tags com três tags.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/TaggingExample2-polaris.png)
Estrutura do JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
]
]
},
```
## Exemplo 3: Grupos de várias tags, tags únicas
Você também pode usar vários conjuntos de grupos de tags com um par de chave/valor único em cada para especificar os critérios para instâncias em um grupo de implantação. Quando você usa grupos de várias tags em um grupo de implantação, apenas as instâncias que são identificadas por todos os grupos de tags são incluídas no grupo de implantação.
**Grupo de tags 1**
| Chave | Valor |
| --- | --- |
| Nome | AppVersion-ABC |
**Grupo de tags 2**
| Chave | Valor |
| --- | --- |
| Região | Norte |
**Grupo de tags 3**
| Chave | Valor |
| --- | --- |
| Tipo | t2.medium |
Você pode ter instâncias em várias regiões e de vários tipos de instância marcados com `Name=AppVersion-ABC`. Neste exemplo, somente as instâncias também marcadas com `Region=North` e `Type=t2.medium` fazem parte do grupo de implantação.
CodeDeploy visualização da configuração do console:
![\[O CodeDeploy console mostra três grupos de tags com uma tag em cada um.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/TaggingExample3-polaris.png)
Estrutura do JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
}
],
]
},
```
## Exemplo 4: Grupos de várias tags, várias tags
Quando você usa vários grupos de tags com várias tags em um ou mais grupos, uma instância deve corresponder a pelo menos uma das tags em cada um dos grupos.
**Grupo de tags 1**
| Chave | Valor |
| --- | --- |
| Environment | Beta |
| Environment | Preparação |
**Grupo de tags 2**
| Chave | Valor |
| --- | --- |
| Região | Norte |
| Região | Sul |
| Região | Leste |
**Grupo de tags 3**
| Chave | Valor |
| --- | --- |
| Tipo | t2.medium |
| Tipo | t2.large |
Neste exemplo, uma instância a ser incluída no grupo de implantação deve ser marcada com (1) `Environment=Beta` ou `Environment=Staging`, com (2) `Region=North`, `Region=South`ou `Region=East` e com (3) `Type=t2.medium` ou `Type=t2.large`.
Para ilustrar, instâncias com os seguintes grupos de tags *estariam* entre as inclusas no grupo de implantação:
+ `Environment=Beta`, `Region=North`,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,`Type=t2.large`
+ `Environment=Staging`,`Region=South`,`Type=t2.large`
Instâncias com os seguintes grupos de tags *não* estariam inclusas no grupo de implantação: Os valores de chave **destacados** fazem com que as instâncias sejam excluídas:
+ `Environment=Beta`, Region=**West**,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,Type=**t2.micro**
+ Environment=**Production**,`Region=South`,`Type=t2.large`
CodeDeploy visualização da configuração do console:
![\[O CodeDeploy console mostra três grupos de tags com várias tags em cada um.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/TaggingExample4-polaris.png)
Estrutura do JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Beta"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Staging"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.large"
}
],
]
},
```
# Trabalhando com instâncias do Amazon EC2 para CodeDeploy
Uma instância do Amazon EC2 é um ambiente de computação virtual que você cria e configura usando o Amazon Elastic Compute Cloud. O Amazon EC2 fornece capacidade de computação escalável na nuvem. AWS Você pode usar o Amazon EC2 para lançar quantos servidores virtuais forem necessários para suas CodeDeploy implantações.
Para obter mais informações sobre o Amazon EC2, consulte o [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
As instruções nesta seção mostram como criar e configurar instâncias do Amazon EC2 para uso em suas CodeDeploy implantações.
**Topics**
+ [Crie uma instância do Amazon EC2 para CodeDeploy](instances-ec2-create.md)
+ [Crie uma instância do Amazon EC2 (modelo)CloudFormation](instances-ec2-create-cloudformation-template.md)
+ [Configurar uma instância do Amazon EC2](instances-ec2-configure.md)
# Crie uma instância do Amazon EC2 para CodeDeploy (AWS CLI ou console do Amazon EC2)
Essas instruções mostram como iniciar uma nova instância do Amazon EC2 que está configurada para uso em CodeDeploy implantações.
Você pode usar nosso CloudFormation modelo para iniciar uma instância do Amazon EC2 executando o Amazon Linux ou o Windows Server que já esteja configurada para uso em CodeDeploy implantações. Não fornecemos um CloudFormation modelo para instâncias do Amazon EC2 executando o Ubuntu Server ou o Red Hat Enterprise Linux (RHEL). Para alternativas ao uso do template, consulte [Trabalhando com instâncias para CodeDeploy](instances.md).
Você pode usar o console do Amazon EC2 ou as APIs do Amazon EC2 para iniciar uma instância do Amazon EC2. AWS CLI
## Iniciar uma instância do Amazon EC2 (console)
### Pré-requisitos
Se você ainda não tiver feito isso, siga as instruções [Começando com CodeDeploy](getting-started-codedeploy.md) para configurar AWS CLI e criar um perfil de instância do IAM.
### Iniciar uma instância do Amazon EC2
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. No painel de navegação, escolha **Instances (Instâncias)** e **Launch Instance (Iniciar instância)**.
1. Na página **Step 1: Choose an Amazon Machine Image (AMI) (Etapa 1: escolher uma imagem de máquina da Amazon (AMI))**, na guia **Quick Start (Início rápido)**, localize o sistema operacional e a versão que você deseja usar, e escolha **Select (Selecionar)**. Você deve escolher um sistema operacional Amazon EC2 AMI suportado pela. CodeDeploy Para obter mais informações, consulte [Sistemas operacionais suportados pelo CodeDeploy agente](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
1. Na página **Etapa 2: Escolher um tipo de instância**, escolha qualquer tipo de instância do Amazon EC2 disponível e, em seguida, **Próximo: Configurar detalhes da instância**.
1. Na página **Etapa 3: Configurar detalhes da instância**, na lista **Perfil do IAM**, escolha o perfil da instância do IAM criada em [Etapa 4: criar um perfil de instância do IAM para as suas instâncias do Amazon EC2](getting-started-create-iam-instance-profile.md). Se você usou o nome de função sugerido, escolha **CodeDeployDemo-EC2-Instance-Profile**. Caso tenha criado seu próprio nome de função, selecione-o.
**nota**
Se uma nuvem privada virtual (VPC) padrão não for exibida na lista **Rede**, você deverá escolher ou criar uma Amazon VPC e uma sub-rede. Selecione **Create new VPC (Criar nova VPC)** ou **Create new subnet (Criar nova sub-rede)** ou ambos. Para obter mais informações, consulte [Sua VPC e sub-redes](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html).
1. Escolha **Next: Add Storage** (Próximo: adicionar armazenamento).
1. Deixe a página **Step 4: Add Storage (Etapa 4: adicionar armazenamento)** inalterada e escolha **Next: Add Tags (Próximo: adicionar tags)**.
1. Na página **Step 5: Add Tags (Etapa 5: Adicionar tags)**, escolha **Add Tag (Adicionar tag)**.
1. Na caixa **Key (Chave)**, digite **Name**. Na caixa **Value (Valor)**, digite **CodeDeployDemo**.
**Importante**
O conteúdo das caixas **Key (Chave)** e **Value (Valor)** faz distinção entre maiúsculas e minúsculas.
1. Escolha **Próximo: configurar grupo de segurança**.
1. Na página **Step 6: Configure Security Group (Etapa 6: configurar o grupo de segurança)**, deixe a opção **Create a new security group (Criar novo grupo de segurança)** selecionada.
Uma função do SSH padrão é configurada para instâncias do Amazon EC2 que executem o Amazon Linux, o Ubuntu Server ou o RHEL. Uma função do RDP padrão é configurada para instâncias do Amazon EC2 que executem o Windows Server.
1. Para abrir a porta HTTP, escolha o botão **Add Rule (Adicionar regra)** e, na lista suspensa **Type (Tipo)**, escolha **HTTP**. Aceite o valor padrão **Source (Origem)** de **Custom 0.0.0.0/0 (Personalizar 0.0.0.0/0)** e selecione **Review and Launch (Revisar e iniciar)**.
**nota**
**Em um ambiente de produção, recomendamos restringir o acesso às portas SSH, RDP e HTTP, em vez de especificar Anywhere 0.0.0.0/0.** CodeDeploy não exige acesso irrestrito à porta e não requer acesso HTTP. Para obter mais informações, consulte [Dicas para proteger sua instância do Amazon EC2](https://aws.amazon.com/articles/1233).
Se uma caixa de diálogo **Boot from General Purpose (SSD) (Inicialização de uso geral (SSD))** for exibida, siga as instruções e escolha **Next (Próximo)**.
1. Deixe a página **Step 7: Review Instance Launch (Etapa 7: revisar o lançamento da instância)** inalterada e escolha **Launch (Iniciar)**.
1. Na caixa de diálogo **Select an existing key pair or create a new key pair (Selecionar um par de chaves existente ou criar um novo par de chaves)**, escolha **Choose an existing key pair (Selecionar um par de chaves existente)** ou **Create a new key pair (Criar um novo par de chaves)**. Se já tiver configurado um par de chaves de instância do Amazon EC2, você pode escolhê-lo aqui.
Caso você ainda não tenha um par de chaves da instância do Amazon EC2, escolha **Create a new key pair** (Criar um novo par de chaves) e atribua a ele um nome reconhecível. Escolha **Download do par de chaves** para fazer download do par de chaves da instância do Amazon EC2 no computador.
**Importante**
Você deve ter um par de chaves se deseja acessar sua instância do Amazon EC2 com SSH ou RDP.
1. Selecione **Launch Instances**.
1. Escolha o ID da sua instância do Amazon EC2. Não continue até que a instância tenha sido iniciada e aprovada em todas as verificações.
### Instale o CodeDeploy agente
O CodeDeploy agente deve ser instalado na sua instância do Amazon EC2 antes de ser usado em CodeDeploy implantações. Para obter mais informações, consulte [Instale o CodeDeploy agente](codedeploy-agent-operations-install.md).
**nota**
Você pode configurar a instalação e as atualizações automáticas do CodeDeploy agente ao criar seu grupo de implantação no console.
## Iniciar uma instância do Amazon EC2 (CLI)
### Pré-requisitos
Se você ainda não tiver feito isso, siga as instruções [Começando com CodeDeploy](getting-started-codedeploy.md) para configurar AWS CLI e criar um perfil de instância do IAM.
### Iniciar uma instância do Amazon EC2
1. **Apenas para Windows Server** Caso você esteja criando uma instância do Amazon EC2 executando o Windows Server, chame os comandos **create-security-group** e **authorize-security-group-ingress** para criar um grupo de segurança que permita acesso RDP (não permitido por padrão) e, como alternativa, acesso HTTP. Por exemplo, para criar um grupo de segurança chamado *CodeDeployDemo-Windows-Security-Group, execute os seguintes comandos, um* por vez:
```
aws ec2 create-security-group --group-name CodeDeployDemo-Windows-Security-Group --description "For launching Windows Server images for use with CodeDeploy"
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 3389 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 3389
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 80 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 80
```
**nota**
Para fins de demonstração, esses comandos criam um grupo de segurança que permite acesso irrestrito para o RDP por meio da porta 3389 e, alternativamente, para o HTTP por meio da porta 80. Como melhor prática, recomendamos restringir o acesso às portas RDP e HTTP. O CodeDeploy não exige acesso irrestrito a portas nem acesso HTTP. Para obter mais informações, consulte [Dicas para proteger sua instância do Amazon EC2](https://aws.amazon.com/articles/1233).
1. Chame o comando **run-instances** para criar e iniciar a instância do Amazon EC2.
Antes de chamar esse comando, você precisará coletar o seguinte:
+ O ID de uma Amazon Machine Image (AMI) (*ami-id*) que você usa para a instância. Para obter o ID, consulte [Encontrar uma AMI adequada](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html).
+ O nome do tipo de instância do Amazon EC2 (*instance-type*) que você cria, como. `t1.micro` Para ver uma lista, consulte [Tipos de instâncias do Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
+ O nome de um perfil de instância do IAM com permissão para acessar o bucket do Amazon S3 onde os arquivos de instalação do CodeDeploy agente para sua região estão armazenados.
Para obter informações sobre como criar um perfil de instância do IAM, consulte [Etapa 4: criar um perfil de instância do IAM para as suas instâncias do Amazon EC2](getting-started-create-iam-instance-profile.md).
+ O nome de um par de chaves de instância do Amazon EC2 (*key-name*) para permitir o acesso SSH a uma instância do Amazon EC2 executando Amazon Linux, Ubuntu Server ou acesso RHEL ou RDP a uma instância do Amazon EC2 executando o Windows Server.
**Importante**
Digite apenas o nome do par de chaves, e não sua extensão de arquivo. Por exemplo, *my-keypair*, e não *my-keypair.pem*.
[Para encontrar um nome de par de chaves, abra o console do Amazon EC2 em https://console.aws.amazon.com /ec2.](https://console.aws.amazon.com/ec2) No painel de navegação, em **Rede e segurança**, escolha **Pares de chaves** e anote o nome do par de chaves na lista.
Para gerar um par de chaves, consulte [Criando seu par de chaves com o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Certifique-se de criar o par de chaves em uma das regiões listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region), no *Referência geral da AWS*. Caso contrário, você não poderá usar o par de chaves de instância do Amazon EC2 com. CodeDeploy
**Para Amazon Linux, RHEL e Ubuntu Server**
Para chamar o comando **run-instances** para iniciar uma instância do Amazon EC2 que executa o Amazon Linux, Ubuntu Server ou RHEL e anexar o perfil de instância do IAM criado em [Etapa 4: criar um perfil de instância do IAM para as suas instâncias do Amazon EC2](getting-started-create-iam-instance-profile.md). Por exemplo:
```
aws ec2 run-instances \
--image-id ami-id \
--key-name key-name \
--count 1 \
--instance-type instance-type \
--iam-instance-profile Name=iam-instance-profile
```
**nota**
Esse comando cria um grupo de segurança padrão para a instância do Amazon EC2 que permite acesso a várias portas, incluindo acesso irrestrito para SSH por meio da porta 22 e, alternativamente, acesso para HTTP por meio da porta 80. Como prática recomendada, recomendamos restringir o acesso somente às portas SSH e HTTP. CodeDeploy não exige acesso irrestrito à porta e não exige acesso à porta HTTP. Para obter mais informações, consulte [Dicas para proteger sua instância do Amazon EC2](https://aws.amazon.com/articles/1233).
**Para Windows Server**
Para chamar o comando **run-instances** a fim de iniciar uma instância do Amazon EC2 que execute o Windows Server e anexar o perfil de instância do IAM criado em [Etapa 4: criar um perfil de instância do IAM para as suas instâncias do Amazon EC2](getting-started-create-iam-instance-profile.md) e especificar o nome do grupo de segurança que você criou na Etapa 1. Por exemplo:
```
aws ec2 run-instances --image-id ami-id --key-name key-name --count 1 --instance-type instance-type --iam-instance-profile Name=iam-instance-profile --security-groups CodeDeploy-Windows-Security-Group
```
Esses comandos iniciam uma única instância do Amazon EC2 com a AMI, o par de chaves e o tipo de instância especificados, com o perfil de instância do IAM especificado, e executam o script especificado durante a inicialização.
1. Observe o valor de `InstanceID` na saída. Se você esquecer esse valor, poderá obtê-lo mais tarde chamando o comando **describe-instances** para o par de chaves de instância do Amazon EC2.
```
aws ec2 describe-instances --filters "Name=key-name,Values=keyName" --query "Reservations[*].Instances[*].[InstanceId]" --output text
```
Use o ID da instância para chamar o **create-tags** comando, que marca a instância do Amazon EC2 para que CodeDeploy você possa encontrá-la posteriormente durante uma implantação. No exemplo a seguir, a tag se chama **CodeDeployDemo**, mas você pode especificar qualquer tag de instância do Amazon EC2 que desejar.
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=CodeDeployDemo
```
Você pode aplicar várias tags a uma instância ao mesmo tempo. Por exemplo:
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=testInstance Key=Region,Value=West Key=Environment,Value=Beta
```
Para verificar se a instância do Amazon EC2 foi iniciada e aprovada em todas as verificações, use o ID de instância para chamar o comando **describe-instance-status**.
```
aws ec2 describe-instance-status --instance-ids instance-id --query "InstanceStatuses[*].InstanceStatus.[Status]" --output text
```
Se a instância tiver sido executada e aprovada em todas as verificações, `ok` será exibido na saída.
### Instale o CodeDeploy agente
O CodeDeploy agente deve ser instalado na sua instância do Amazon EC2 antes de ser usado em CodeDeploy implantações. Para obter mais informações, consulte [Instale o CodeDeploy agente](codedeploy-agent-operations-install.md).
**nota**
Você pode configurar a instalação e as atualizações automáticas do CodeDeploy agente ao criar seu grupo de implantação no console.
# Crie uma instância do Amazon EC2 para CodeDeploy (modelo)CloudFormation
Você pode usar nosso CloudFormation modelo para iniciar rapidamente uma instância do Amazon EC2 executando o Amazon Linux ou o Windows Server. Você pode usar o AWS CLI, o CodeDeploy console ou o AWS APIs para iniciar a instância com o modelo. Além de iniciar a instância, o template faz o seguinte:
+ Instrui CloudFormation a conceder permissão à instância para participar das CodeDeploy implantações.
+ Marca a instância para que CodeDeploy possa encontrá-la durante uma implantação.
+ Instala e executa o CodeDeploy agente na instância.
Você não precisa usar o nosso CloudFormation para configurar uma instância do Amazon EC2. Para conhecer alternativas, consulte [Trabalhando com instâncias para CodeDeploy](instances.md).
Não fornecemos um CloudFormation modelo para instâncias do Amazon EC2 executando o Ubuntu Server ou o Red Hat Enterprise Linux (RHEL).
**Topics**
+ [Antes de começar](#instances-ec2-create-cloudformation-template-before)
+ [Execute uma instância do Amazon EC2 com o CloudFormation modelo (console)](#instances-ec2-create-cloudformation-template-console)
+ [Execute uma instância do Amazon EC2 com o CloudFormation modelo ()AWS CLI](#instances-ec2-create-cloudformation-template-cli)
## Antes de começar
Antes de usar o CloudFormation modelo para iniciar instâncias do Amazon EC2, certifique-se de concluir as etapas a seguir.
1. Certifique-se de ter criado um usuário administrativo, conforme descrito em [Etapa 1: configuração](getting-started-setting-up.md). Verifique se o usuário tem as seguintes permissões mínimas e adicione as que não estão presentes:
+ cloudformation:\$1
+ codedeploy:\$1
+ ec2:\$1
+ objetivo: AddRoleToInstanceProfile
+ objetivo: CreateInstanceProfile
+ objetivo: CreateRole
+ objetivo: DeleteInstanceProfile
+ objetivo: DeleteRole
+ objetivo: DeleteRolePolicy
+ objetivo: GetRole
+ objetivo: DeleteRolePolicy
+ objetivo: PutRolePolicy
+ objetivo: RemoveRoleFromInstanceProfile
1. Certifique-se de ter um par de chaves de instância para permitir o acesso SSH à instância do Amazon EC2 executando o Amazon Linux ou acesso RDP à instância que executa o Windows Server.
[Para encontrar um nome de par de chaves, abra o console do Amazon EC2 em https://console.aws.amazon.com /ec2.](https://console.aws.amazon.com/ec2) No painel de navegação, em **Rede e segurança**, escolha **Pares de chaves** e anote o nome do par de chaves na lista.
Para gerar um novo par de chaves, consulte [Criando seu par de chaves com o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Verifique se o par de chaves foi criado em uma das regiões listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) no *Referência geral da AWS*. Caso contrário, você não poderá usar o par de chaves de instância com o CodeDeploy.
## Execute uma instância do Amazon EC2 com o CloudFormation modelo (console)
1. Faça login no Console de gerenciamento da AWS e abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
**Importante**
Faça login no Console de gerenciamento da AWS com a mesma conta que você usou[Começando com CodeDeploy](getting-started-codedeploy.md). Na barra de navegação, no seletor de região, escolha uma das regiões listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) em. *Referência geral da AWS* CodeDeploy suporta somente essas regiões.
1. Selecione **Create Stack** (Criar pilha).
1. Em **Escolher um modelo**, selecione **Especificar um URL do modelo do Amazon S3**. Na caixa, digite a localização do CloudFormation modelo para sua região e escolha **Avançar**.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
1. Na caixa **Stack name (Nome da pilha)**, digite um nome para a pilha (por exemplo, **CodeDeployDemoStack**).
1. Em **Parâmetros**, digite o seguinte e escolha **Avançar**.
+ Para **InstanceCount**, digite o número de instâncias que você deseja iniciar. (Recomendamos deixar o padrão de **1**.)
+ Para **InstanceType**, digite o tipo de instância que você deseja iniciar (ou deixe o padrão de **t1.micro**).
+ Para **KeyPairName**, digite o nome do par de chaves da instância. Digite apenas o nome do par de chaves, e não sua extensão de arquivo.
+ Em **OperatingSystem**box, digite **Windows** para iniciar instâncias executando o Windows Server (ou deixe o padrão do **Linux**).
+ Para **SSHLocation**, digite o intervalo de endereços IP a ser usado para se conectar à instância com SSH ou RDP (ou deixe o padrão de **0.0.0.0/0**).
**Importante**
O padrão de **0.0.0.0/0** é fornecido apenas para fins de demonstração. CodeDeploy não exige que as instâncias do Amazon EC2 tenham acesso irrestrito às portas. Como prática recomendada, recomendamos restringir o acesso às portas SSH (e HTTP). Para obter mais informações, consulte [Dicas para proteger sua instância do Amazon EC2](https://aws.amazon.com/articles/1233).
+ Para **TagKey**, digite a tag de instância que a chave CodeDeploy usará para identificar as instâncias durante a implantação (ou deixe o padrão de **Nome**).
+ Para **TagValue**, digite o valor da tag de instância CodeDeploy que será usado para identificar as instâncias durante a implantação (ou deixe o padrão de **CodeDeployDemo**).
1. Na página **Opções**, deixe as caixas de opções em branco e escolha **Avançar**.
**Importante**
CloudFormation as tags são diferentes das CodeDeploy tags. CloudFormation usa tags para simplificar a administração da sua infraestrutura. CodeDeploy usa tags para identificar instâncias do Amazon EC2. Você especificou tags do CodeDeploy na página **Specify Parameters (Especificar parâmetros)**.
1. Na página de **revisão**, em **Capacidades**, selecione a caixa **Eu reconheço que CloudFormation podem criar recursos do IAM** e, em seguida, escolha **Criar**.
**Depois de criar CloudFormation a pilha e iniciar as instâncias do Amazon EC2, no CloudFormation console**,** CREATE\$1COMPLETE será exibido na coluna Status.** Esse processo pode levar alguns minutos.
Para verificar se o CodeDeploy agente está sendo executado nas instâncias do Amazon EC2[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md), consulte e prossiga para. [Crie um aplicativo com CodeDeploy](applications-create.md)
## Execute uma instância do Amazon EC2 com o CloudFormation modelo ()AWS CLI
1. Use nosso CloudFormation modelo em uma chamada para o **create-stack** comando. Essa pilha iniciará uma nova instância do Amazon EC2 com CodeDeploy o agente instalado.
Para iniciar uma instância do Amazon EC2 executando o Amazon Linux:
```
aws cloudformation create-stack \
--stack-name CodeDeployDemoStack \
--template-url templateURL \
--parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro \
ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Linux \
ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name \
ParameterKey=TagValue,ParameterValue=CodeDeployDemo \
--capabilities CAPABILITY_IAM
```
Para iniciar uma instância do Amazon EC2 executando o Windows Server:
```
aws cloudformation create-stack --stack-name CodeDeployDemoStack --template-url template-url --parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Windows ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name ParameterKey=TagValue,ParameterValue=CodeDeployDemo --capabilities CAPABILITY_IAM
```
*keyName*é o nome do par de chaves da instância. Digite apenas o nome do par de chaves, e não sua extensão de arquivo.
*template-url*é a localização do CloudFormation modelo para sua região:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
Esse comando cria uma CloudFormation pilha chamada**CodeDeployDemoStack**, usando o CloudFormation modelo no bucket do Amazon S3 especificado. A instância do Amazon EC2 se baseia no tipo de instância t1.micro, mas você pode usar qualquer tipo. Ela é marcada com o valor **CodeDeployDemo**, mas você pode marcá-la com qualquer valor. Ela tem o par de chaves de instância especificado aplicado.
1. Chame o **describe-stacks** comando para verificar se a CloudFormation pilha chamada **CodeDeployDemoStack** foi criada com sucesso:
```
aws cloudformation describe-stacks --stack-name CodeDeployDemoStack --query "Stacks[0].StackStatus" --output text
```
Não prossiga até que o valor `CREATE_COMPLETE` seja retornado.
Para verificar se o CodeDeploy agente está sendo executado na instância do Amazon EC2[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md), consulte e prossiga para. [Crie um aplicativo com CodeDeploy](applications-create.md)
# Configurar uma instância do Amazon EC2 para trabalhar com CodeDeploy
Essas instruções mostram como configurar uma instância do Amazon EC2 executando Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) ou Windows Server para uso em implantações. CodeDeploy
**nota**
Se você não tiver uma instância do Amazon EC2, poderá usar o CloudFormation modelo para iniciar uma executando o Amazon Linux ou o Windows Server. Não fornecemos um modelo para o Ubuntu Server ou o RHEL.
## Etapa 1: Verificar se um perfil de instância do IAM está anexado à sua instância do EC2
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. No painel de navegação, em **Instâncias**, escolha **Instâncias**.
1. Navegue e escolha sua instância do Amazon EC2 na lista.
1. No painel de detalhes, na guia **Descrição**, anote o valor contido no campo **Perfil do IAM** e, então, prossiga para a próxima seção.
Se o campo estiver vazio, você poderá anexar um perfil de instância do IAM à instância. Para obter informações, consulte [Anexar um perfil do IAM a uma instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
## Etapa 2: Verificar se o perfil da instância do IAM tem as permissões de acesso corretas
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. Navegue e escolha o nome do perfil do IAM anotado na etapa 4 da seção anterior.
**nota**
Se você quiser usar a função de serviço gerada pelo CloudFormation modelo em vez da que você criou seguindo as instruções em[Etapa 2: criar uma função de serviço para CodeDeploy](getting-started-create-service-role.md), observe o seguinte:
Em algumas versões do nosso CloudFormation modelo, o nome de exibição do perfil de instância do IAM gerado e anexado às instâncias do Amazon EC2 não é o mesmo que o nome de exibição no console do IAM. Por exemplo, o perfil de instância do IAM pode ter um nome para exibição de `CodeDeploySampleStack-expnyi6-InstanceRoleInstanceProfile-IK8J8A9123EX`, enquanto o perfil de instância do IAM no console do IAM pode ter um nome para exibição de `CodeDeploySampleStack-expnyi6-InstanceRole-C5P33V1L64EX`.
Para ajudá-lo a identificar o perfil de instância no console do IAM, você verá que o prefixo de `CodeDeploySampleStack-expnyi6-InstanceRole` é o mesmo para ambos. Para obter informações sobre por que esses nomes para exibição podem ser diferentes, consulte [Perfis de instância](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html).
1. Selecione a guia **Relacionamentos de confiança**. Se não houver uma entrada em **Entidades de confiança** em que esteja escrito **Provedor(es) de identidade ec2.amazonaws.com**, não será possível usar essa instância do Amazon EC2. Pare e crie uma instância do Amazon EC2 usando as informações em [Trabalhando com instâncias para CodeDeploy](instances.md).
Se houver uma entrada que diz **O (s) provedor (es) de identidade ec2.amazonaws.com** e você estiver armazenando seus aplicativos somente em GitHub repositórios, vá para. [Etapa 3: Marcar a instância do Amazon EC2](#instances-ec2-configure-3-tag-instance)
Se houver uma entrada indicando **Provedor(es) de identidade ec2.amazonaws.com** e você estiver armazenando suas aplicações somente em buckets do Amazon S3, escolha a guia **Permissões**.
1. Se houver uma política na área **Permissions policies (Políticas de permissões)**, expanda a política e selecione **Edit policy (Editar política)**.
1. Selecione a guia **JSON**. Se você estiver armazenando suas aplicações em buckets do Amazon S3, certifique-se de que `"s3:Get*"` e `"s3:List*"` estejam na lista de ações especificadas.
Essa lista pode ser semelhante a:
```
{"Statement":[{"Resource":"*","Action":[
... Some actions may already be listed here ...
"s3:Get*","s3:List*"
... Some more actions may already be listed here ...
],"Effect":"Allow"}]}
```
Ou ser algo neste estilo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "*"
}
]
}
```
------
Se `"s3:Get*"` e `"s3:List*"` não estiverem na lista de ações especificadas, escolha **Editar** para adicioná-las e escolha **Salvar**. (Se nem `"s3:Get*"` nem `"s3:List*"` for a última ação na lista, certifique-se de adicionar uma vírgula após a ação, para que o documento de política seja validado.)
**nota**
Recomendamos que você restrinja essa política somente aos buckets do Amazon S3 que suas instâncias do Amazon EC2 precisam acessar. Certifique-se de dar acesso aos buckets do Amazon S3 que contêm o agente. CodeDeploy Caso contrário, poderá ocorrer um erro quando o CodeDeploy agente for instalado ou atualizado nas instâncias. Para conceder ao perfil da instância do IAM acesso somente a alguns buckets do kit de CodeDeploy recursos no Amazon S3, use a política a seguir, mas remova as linhas dos buckets aos quais você deseja impedir o acesso:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
## Etapa 3: Marcar a instância do Amazon EC2
Para obter instruções sobre como marcar a instância do Amazon EC2 para que ela CodeDeploy possa ser encontrada durante uma implantação, consulte Como [trabalhar com tags no console e, em](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console) seguida, retorne a esta página.
**nota**
Você pode marcar a instância do Amazon EC2 com qualquer chave e valor desejado. Certifique-se de especificar essa chave e esse valor quando fizer a implantação.
## Etapa 4: instalar o AWS CodeDeploy agente na instância do Amazon EC2
Para obter instruções sobre como instalar o CodeDeploy agente na instância do Amazon EC2 e verificar se ele está em execução[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md), consulte e prossiga para. [Crie um aplicativo com CodeDeploy](applications-create.md)
# Trabalhando com instâncias locais para CodeDeploy
Uma instância local é qualquer dispositivo físico que não seja uma instância do Amazon EC2 que possa executar CodeDeploy o agente e se conectar a endpoints de serviço AWS público.
A implantação de uma revisão do CodeDeploy aplicativo em uma instância local envolve duas etapas principais:
+ **Etapa 1** — Configure cada instância local, registre-a e CodeDeploy, em seguida, marque-a.
+ **Etapa 2:** implantar revisões de aplicações na instância on-premises.
**nota**
Para fazer testes com a criação e implantação de uma revisão de aplicativo de amostra em uma instância local corretamente configurada e registrada, consulte [Tutorial: Implantar um aplicativo em uma instância local com CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md). Para obter informações sobre instâncias locais e como elas funcionam CodeDeploy, consulte[Trabalhando com instâncias locais para CodeDeploy](#instances-on-premises).
Se não quiser mais que uma instância on-premises seja usada nas implantações, basta remover as tags de instâncias on-premises dos grupos de implantação. Para uma abordagem mais robusta, remova as tags de instâncias locais da instância. Você também pode cancelar explicitamente o registro de uma instância local para que ela não possa mais ser usada em nenhuma implantação. Para obter mais informações, consulte [Gerenciando operações de instâncias locais em CodeDeploy](on-premises-instances-operations.md).
As instruções nesta seção mostram como configurar uma instância local e, em seguida, registrá-la e marcá-la CodeDeploy para que ela possa ser usada em implantações. Esta seção também descreve como usar CodeDeploy para obter informações sobre instâncias locais e cancelar o registro de uma instância local depois que você não planeja mais implantá-la.
**Topics**
+ [Pré-requisitos para configurar uma instância on-premises](instances-on-premises-prerequisites.md)
+ [Registrar uma instância local](on-premises-instances-register.md)
+ [Gerenciando operações de instâncias on-premises](on-premises-instances-operations.md)
# Pré-requisitos para configurar uma instância on-premises
Os seguintes pré-requisitos devem ser atendidos para que você possa registrar uma instância local.
**Importante**
Se você estiver usando o [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando e atualizando periodicamente as credenciais temporárias geradas com o AWS Security Token Service (AWS STS), há outros pré-requisitos. Para mais informações, consulte [Pré-requisitos de registro do ARN de sessão do IAM](register-on-premises-instance-iam-session-arn.md#register-on-premises-instance-iam-session-arn-prerequisites).
**Requisitos do dispositivo**
O dispositivo que você deseja preparar, registrar e marcar como uma instância local CodeDeploy deve estar executando um sistema operacional compatível. Para ver uma lista, consulte [Sistemas operacionais suportados pelo CodeDeploy agente](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
Se seu sistema operacional não for suportado, o CodeDeploy agente estará disponível como código aberto para você se adaptar às suas necessidades. Para obter mais informações, consulte o repositório do [CodeDeploy agente](https://github.com/aws/aws-codedeploy-agent) em GitHub.
**Comunicação de saída**
A instância local deve ser capaz de se conectar aos endpoints de AWS serviço público com os quais se comunicar. CodeDeploy
O CodeDeploy agente se comunica de saída usando HTTPS pela porta 443.
**Controle administrativo**
A conta local ou de rede usada na instância on-premises para configurar essa instância deve ser capaz de ser executada como `sudo` ou `root` (para o Ubuntu Server) ou como administrador (para o Windows Server).
**Permissões do IAM**
A identidade do IAM que você usa para registrar a instância on-premises deve receber permissões para concluir o registro (e cancelar o registro da instância on-premises, conforme necessário).
Além da política descrita em [Etapa 3: limitar as permissões do CodeDeploy usuário](getting-started-policy.md), verifique se a identidade do IAM responsável pela chamada também tem a política adicional a seguir anexada.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser"
],
"Resource": "*"
}
]
}
```
------
Para obter informações sobre como anexar políticas do IAM, consulte [Gerenciar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html).
# Registre uma instância local com CodeDeploy
Para registrar uma instância local, você deve usar uma identidade do IAM para autenticar suas solicitações. É possível escolher entre as seguintes opções para o método de identidade e registro do IAM utilizado:
+ Use um ARN de função do IAM para autenticar solicitações.
+ Use o [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando e as credenciais temporárias atualizadas periodicamente geradas com o AWS Security Token Service (AWS STS) para configurar manualmente a maioria das opções de registro. Essa opção oferece o mais alto nível de segurança, porque a autenticação ocorre usando um token temporário que expira e deve ser atualizado periodicamente. Essa opção é recomendada para implantações de produção com qualquer tamanho. Para mais informações, consulte [Use o register-on-premises-instance comando (ARN da sessão do IAM) para registrar uma instância local](register-on-premises-instance-iam-session-arn.md).
+ (Não recomendado) Use um ARN de usuário do IAM para autenticar solicitações.
+ Use o comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) para o processo de registro mais automatizado. Essa opção só deve ser usada para implantações que não sejam de produção, nas quais a segurança seja menos preocupante. Essa opção é menos segura porque usa credenciais estáticas (permanentes) para autenticação. Essa opção funciona bem para registrar uma única instância on-premises. Para mais informações, consulte [Usar o comando register (ARN de usuário do IAM) para registrar uma instância on-premises](instances-on-premises-register-instance.md).
+ Use o comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) para configurar manualmente a maioria das opções de registro. Adequado para registrar um pequeno número de instâncias locais. Para mais informações, consulte [Use o register-on-premises-instance comando (ARN do usuário do IAM) para registrar uma instância local](register-on-premises-instance-iam-user-arn.md).
**Topics**
+ [Use o register-on-premises-instance comando (ARN da sessão do IAM) para registrar uma instância local](register-on-premises-instance-iam-session-arn.md)
+ [Usar o comando register (ARN de usuário do IAM) para registrar uma instância on-premises](instances-on-premises-register-instance.md)
+ [Use o register-on-premises-instance comando (ARN do usuário do IAM) para registrar uma instância local](register-on-premises-instance-iam-user-arn.md)
# Use o register-on-premises-instance comando (ARN da sessão do IAM) para registrar uma instância local
Para obter o máximo controle sobre a autenticação e o registro de suas instâncias locais, você pode usar o [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando e as credenciais temporárias atualizadas periodicamente geradas com o (). AWS Security Token Service AWS STS Uma função estática do IAM para a instância assume a função dessas AWS STS credenciais atualizadas para realizar operações de implantação. CodeDeploy
Esse método é mais útil quando você precisa registrar um grande número de instâncias. Ele permite que você automatize o processo de registro com CodeDeploy. Você pode usar seu próprio sistema de identidade e autenticação para autenticar instâncias locais e distribuir as credenciais de sessão do IAM do serviço para as instâncias com as quais serão usadas. CodeDeploy
**nota**
Como alternativa, você pode usar um usuário compartilhado do IAM distribuído para todas as instâncias locais para chamar a AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API e recuperar as credenciais da sessão para instâncias locais. Esse método é menos seguro e não é recomendado para ambientes de produção ou críticos.
Use as informações nos tópicos a seguir para configurar uma instância local usando credenciais de segurança temporárias geradas com. AWS STS
**Topics**
+ [Pré-requisitos de registro do ARN de sessão do IAM](#register-on-premises-instance-iam-session-arn-prerequisites)
+ [Etapa 1: criar o perfil do IAM que as instâncias on-premises assumirão](#register-on-premises-instance-iam-session-arn-1)
+ [Etapa 2: gerar credenciais temporárias para uma instância individual usando AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ [Etapa 3: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-session-arn-3)
+ [Etapa 4: Preparar uma instância local para CodeDeploy implantações](#register-on-premises-instance-iam-session-arn-4)
+ [Etapa 5: registrar a instância local com CodeDeploy](#register-on-premises-instance-iam-session-arn-5)
+ [Etapa 6: marcar a instância on-premises](#register-on-premises-instance-iam-session-arn-6)
+ [Etapa 7: implantar revisões de aplicações na instância on-premises](#register-on-premises-instance-iam-session-arn-7)
+ [Etapa 8: acompanhar implantações na instância on-premises](#register-on-premises-instance-iam-session-arn-8)
## Pré-requisitos de registro do ARN de sessão do IAM
Além dos pré-requisitos listados em [Pré-requisitos para configurar uma instância on-premises](instances-on-premises-prerequisites.md), os seguintes requisitos adicionais devem ser atendidos:
**Permissões do IAM**
A identidade do IAM que você usa para registrar uma instância local deve receber permissões para realizar CodeDeploy operações. Verifique se a política gerenciada **AWSCodeDeployFullAccess** está anexada à identidade do IAM. Para obter mais informações, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Manual do usuário do IAM*.
**Sistema para atualizar credenciais temporárias**
Se você usar um ARN de sessão do IAM para registrar instâncias locais, deverá ter um sistema em vigor para atualizar periodicamente as credenciais temporárias. As credenciais temporárias expiram depois de uma hora ou antes quando um período mais curto é especificado no momento em que as credenciais são geradas. Existem dois métodos para atualizar as credenciais:
+ **Método 1**: use o sistema de identidade e autenticação instalado na sua rede corporativa com um script CRON que faça uma sondagem periódica do sistema de identidade e autenticação e que copie as credenciais da última sessão para a instância. Isso permite que você integre sua estrutura de autenticação e identidade AWS sem precisar fazer alterações no CodeDeploy agente ou no serviço para oferecer suporte aos tipos de autenticação que você usa em sua organização.
+ **Método 2**: Execute periodicamente um trabalho CRON na instância para chamar a AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)ação e gravar as credenciais da sessão em um arquivo que o CodeDeploy agente possa acessar. Esse método ainda requer um usuário do IAM e a cópia de credenciais na instância local, mas você pode reutilizar o mesmo usuário do IAM e as mesmas credenciais por toda a sua frota de instâncias locais.
**nota**
Independentemente de você estar usando o método 1 ou 2, você deve configurar um processo para reiniciar o CodeDeploy agente depois que as credenciais da sessão temporária forem atualizadas para que as novas credenciais entrem em vigor.
Para obter informações sobre como criar e trabalhar com AWS STS credenciais, consulte [Referência AWS Security Token Service da API](https://docs.aws.amazon.com/STS/latest/APIReference/) e [Uso de credenciais de segurança temporárias para solicitar acesso aos AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) recursos.
## Etapa 1: criar o perfil do IAM que as instâncias on-premises assumirão
Você pode usar o console do IAM AWS CLI ou o console do IAM para criar uma função do IAM que será usada por suas instâncias locais para autenticação e interação. CodeDeploy
Você só precisa criar uma função do IAM. Cada uma das suas instâncias locais pode assumir essa função para recuperar as credenciais de segurança temporárias que fornecem as permissões concedidas a essa função.
A função que você criar exigirá as seguintes permissões para acessar os arquivos necessários para instalar o CodeDeploy agente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Recomendamos que você restrinja essa política somente para os buckets do Amazon S3 que a sua instância on-premises precisa acessar. Se você restringir essa política, certifique-se de dar acesso aos buckets do Amazon S3 que contêm o agente. CodeDeploy Caso contrário, poderá ocorrer um erro sempre que o CodeDeploy agente for instalado ou atualizado na instância local. Para obter mais informações sobre como controlar o acesso aos buckets do Amazon S3, consulte [Gerenciar permissões de acesso aos recursos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
**Para criar perfil do IAM**
1. Chame o comando [create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) usando a opção `--role-name` para especificar um nome para a função do IAM (por exemplo, `CodeDeployInstanceRole`) e a opção `--assume-role-policy-document` para fornecer as permissões.
Ao criar a função do IAM para essa instância, você pode dar a ela o nome `CodeDeployInstanceRole` e incluir as permissões necessárias em um arquivo chamado `CodeDeployRolePolicy.json`:
```
aws iam create-role --role-name CodeDeployInstanceRole --assume-role-policy-document file://CodeDeployRolePolicy.json
```
1. Na saída da chamada para o comando **create-role**, anote o valor do campo ARN. Por exemplo:
```
arn:aws:iam::123456789012:role/CodeDeployInstanceRole
```
Você precisará do ARN da função ao usar a AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API para gerar credenciais de curto prazo para cada instância.
Para obter mais informações sobre a criação de funções do IAM, consulte [Como criar uma função para delegar permissões a um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do usuário do IAM*.
Para obter informações sobre como atribuir permissões a uma função existente, consulte [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)na [Referência de AWS CLI Comandos](https://docs.aws.amazon.com/cli/latest/reference/).
## Etapa 2: gerar credenciais temporárias para uma instância individual usando AWS STS
Antes de gerar as credenciais temporárias que serão usadas para registrar uma instância local, você deve criar ou escolher a identidade do IAM (usuário ou função) para a qual você gerará essas credenciais temporárias. A permissão `sts:AssumeRole` deve ser incluída nas configurações de política para essa identidade do IAM.
Para obter informações sobre como conceder `sts:AssumeRole` permissões a uma identidade do IAM, consulte [Criação de uma função para delegar permissões a um AWS serviço e. [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)
Existem duas maneiras de gerar as credenciais temporárias:
+ Use o comando [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) com o AWS CLI. Por exemplo:
```
aws sts assume-role --role-arn arn:aws:iam::12345ACCOUNT:role/role-arn --role-session-name session-name
```
Em que:
+ *12345ACCOUNT*é o número da conta de 12 dígitos da sua organização.
+ *role-arn*é o ARN da função a ser assumida, que você gerou em. [Etapa 1: criar o perfil do IAM que as instâncias on-premises assumirão](#register-on-premises-instance-iam-session-arn-1)
+ *session-name*é o nome que você deseja dar à sessão de função que você está criando agora.
**nota**
Se você usa um script CRON que pesquisa periodicamente o sistema de identidade e autenticação e copia as credenciais da sessão mais recente para a instância (método 1 para atualizar as credenciais temporárias descrito em[Pré-requisitos de registro do ARN de sessão do IAM](#register-on-premises-instance-iam-session-arn-prerequisites)), você pode usar qualquer SDK compatível para chamar. AWS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
+ Use uma ferramenta fornecida pela AWS.
A aws-codedeploy-session-helper ferramenta gera AWS STS credenciais e as grava em um arquivo que você coloca na instância. Essa ferramenta é mais adequada para o método 2 de atualização de credenciais temporárias, descrito em [Pré-requisitos de registro do ARN de sessão do IAM](#register-on-premises-instance-iam-session-arn-prerequisites). Nesse método, a aws-codedeploy-session-helper ferramenta é colocada em cada instância e executa o comando usando as permissões de um usuário do IAM. Cada instância usa as mesmas credenciais do usuário do IAM em conjunto com essa ferramenta.
Para obter mais informações, consulte o [aws-codedeploy-session-helper](https://github.com/awslabs/aws-codedeploy-samples/tree/master/utilities/aws-codedeploy-session-helper) GitHub repositório.
**nota**
Depois de ter criado as credenciais de sessão do IAM, coloque-as em qualquer parte da instância local. Na próxima etapa, você configurará o CodeDeploy agente para acessar as credenciais nesse local.
Antes de continuar, verifique se o sistema que você usará para atualizar periodicamente as credenciais temporárias está em vigor. Se as credenciais temporárias não forem atualizadas, as implantações na instância local falharão. Para obter mais informações, consulte "Sistema para atualizar credenciais temporárias", em [Pré-requisitos de registro do ARN de sessão do IAM](#register-on-premises-instance-iam-session-arn-prerequisites).
## Etapa 3: adicionar um arquivo de configuração à instância on-premises
Adicione um arquivo de configuração à instância on-premises usando permissões raiz ou de administrador. Esse arquivo de configuração é usado para declarar as credenciais do IAM e a AWS região de destino a ser usada. CodeDeploy O arquivo deve ser adicionado a um local específico na instância on-premises. O arquivo deve incluir o ARN da sessão temporária do IAM, seu ID de chave secreta e chave de acesso secreta e a região de destino AWS .
**Para adicionar um arquivo de configuração**
1. Crie um arquivo chamado `codedeploy.onpremises.yml` (para uma instância on-premises do Ubuntu Server ou do RHEL) ou `conf.onpremises.yml` (para uma instância on-premises do Windows Server) na seguinte localização da instância on-premises:
+ Para Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Para Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Use um editor de texto para adicionar as seguintes informações ao arquivo `codedeploy.onpremises.yml` (Linux) ou `conf.onpremises.yml` (Windows) recém-criado:
```
---
iam_session_arn: iam-session-arn
aws_credentials_file: credentials-file
region: supported-region
```
Em que:
+ *iam-session-arn*é o ARN da sessão do IAM em que você anotou. [Etapa 2: gerar credenciais temporárias para uma instância individual usando AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *credentials-file*é o local do arquivo de credenciais para o ARN da sessão temporária, conforme observado em. [Etapa 2: gerar credenciais temporárias para uma instância individual usando AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *supported-region*é uma das regiões que oferecem CodeDeploy suporte, conforme listado em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) em *Referência geral da AWS*.
## Etapa 4: Preparar uma instância local para CodeDeploy implantações
**Instale e configure o AWS CLI **
Instale e configure o AWS CLI na instância local. (Eles AWS CLI serão usados para baixar e instalar o CodeDeploy agente na instância local.)
1. Para instalar o AWS CLI na instância local, siga as instruções em [Como configurar com o AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) no *Guia do AWS Command Line Interface usuário*.
**nota**
CodeDeploy comandos para trabalhar com instâncias locais foram disponibilizados na versão 1.7.19 do. AWS CLI Se você tiver uma versão do AWS CLI já instalada, poderá verificar sua versão ligando para**aws --version**.
1. Para configurar o AWS CLI na instância local, siga as instruções em [Configurando o AWS CLI no Guia](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) do *AWS Command Line Interface usuário*.
**Importante**
Ao configurar o AWS CLI (por exemplo, chamando o **aws configure** comando), certifique-se de especificar o ID da chave secreta e a chave de acesso secreta de um usuário do IAM que tenha, no mínimo, as permissões descritas em[Pré-requisitos de registro do ARN de sessão do IAM](#register-on-premises-instance-iam-session-arn-prerequisites).
**Defina a variável de AWS\$1REGION ambiente (somente Ubuntu Server e RHEL)**
Se você não estiver executando o Ubuntu Server ou o RHEL na sua instância local, pule esta etapa e vá diretamente para “Instalar o CodeDeploy agente”.
Instale o CodeDeploy agente em uma instância local do Ubuntu Server ou do RHEL e habilite a instância para atualizar o CodeDeploy agente sempre que uma nova versão estiver disponível. Isso é feito configurando a variável de ambiente `AWS_REGION` na instância como o identificador de uma das regiões com suporte pelo CodeDeploy. Recomendamos que você defina o valor para a região em que seus CodeDeploy aplicativos, grupos de implantação e revisões de aplicativos estão localizados (por exemplo,`us-west-2`). Para obter uma lista de regiões, consulte [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region), na *Referência geral da AWS*.
Para definir a variável de ambiente, chame o seguinte usando o terminal:
```
export AWS_REGION=supported-region
```
Onde *supported-region* está o identificador da região (por exemplo,`us-west-2`).
**Instale o CodeDeploy agente**
+ Para uma instância on-premises do Ubuntu Server, siga as instruções em [Instale o CodeDeploy agente para o Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md) e depois retorne a esta página.
+ Para uma instância on-premises do RHEL, siga as instruções em [Instale o CodeDeploy agente para Amazon Linux ou RHEL](codedeploy-agent-operations-install-linux.md) e depois retorne a esta página.
+ Para uma instância on-premises do Windows Server, siga as instruções em [Instale o CodeDeploy agente para Windows Server](codedeploy-agent-operations-install-windows.md) e depois retorne a esta página.
## Etapa 5: registrar a instância local com CodeDeploy
As instruções nesta etapa supõem que você esteja registrando a instância on-premises a partir dela mesma. Você pode registrar uma instância local a partir de um dispositivo ou instância separada que a tenha AWS CLI instalada e configurada.
Use o AWS CLI para registrar a instância local CodeDeploy para que ela possa ser usada em implantações.
Antes de usar o AWS CLI, você precisará do ARN das credenciais de sessão temporária que você criou. [Etapa 3: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-session-arn-3) Por exemplo, para uma instância identificada como `AssetTag12010298EX`:
```
arn:sts:iam::123456789012:assumed-role/CodeDeployInstanceRole/AssetTag12010298EX
```
Use o comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html), especificando:
+ Um nome que identifique de forma exclusiva a instância on premises (com a opção `--instance-name`).
**Importante**
Para ajudar a identificar a instância local, especialmente para fins de depuração, recomendamos que você especifique um nome que seja mapeado para alguma característica exclusiva da instância local (por exemplo, o nome da sessão das credenciais do STS e o número de série ou um identificador interno de ativo, se aplicável). Se você especificar um endereço MAC como nome, saiba que os endereços MAC contêm caracteres que CodeDeploy não são permitidos, como dois pontos (:). Para obter uma lista de caracteres permitidos, consulte [CodeDeploy cotas](limits.md).
+ O ARN da sessão do IAM que você configurou para autenticar várias instâncias locais em [Etapa 1: criar o perfil do IAM que as instâncias on-premises assumirão](#register-on-premises-instance-iam-session-arn-1).
Por exemplo:
```
aws deploy register-on-premises-instance --instance-name name-of-instance --iam-session-arn arn:aws:sts::account-id:assumed-role/role-to-assume/session-name
```
Em que:
+ *name-of-instance*é o nome que você usa para identificar a instância local, como`AssetTag12010298EX`.
+ *account-id*é o ID da conta de 12 dígitos da sua organização, como. `111222333444`
+ *role-to-assume*é o nome da função do IAM que você criou para a instância, como`CodeDeployInstanceRole`.
+ *session-name*é o nome da função da sessão em que você especificou[Etapa 2: gerar credenciais temporárias para uma instância individual usando AWS STS](#register-on-premises-instance-iam-session-arn-2).
## Etapa 6: marcar a instância on-premises
Você pode usar o console AWS CLI ou o CodeDeploy console para marcar a instância local. (CodeDeployusa tags de instância local para identificar os alvos de implantação durante uma implantação.)
**Para marcar a instância on-premises (CLI)**
+ Chame o comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html), especificando:
+ O nome que identifica de forma exclusiva a instância on-premises (com a opção `--instance-names`).
+ O nome da chave da tag de instância on-premises e o valor da tag que você deseja usar (com a opção `--tags`). Você deve especificar um nome e um valor. CodeDeploy não permite tags de instância local que tenham somente valores.
Por exemplo:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Para marcar a instância on-premises (console)**
1. Faça login no Console de gerenciamento da AWS e abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Faça login com o mesmo usuário que você configurou em [Começando com CodeDeploy](getting-started-codedeploy.md).
1. No painel de navegação, expanda **Implantar** e escolha **Instâncias on-premises**.
1. Na lista de instâncias locais, selecione nome da instância local que deseja marcar.
1. Na lista de tags, selecione ou insira a chave e o valor da tag desejados. Após inserir a chave e o valor da tag, outra linha será exibida. Isso pode ser repetido para até 10 tags. Para remover uma tag, selecione **Remover**.
1. Depois de adicionar as tags, escolha **Atualizar tags**.
## Etapa 7: implantar revisões de aplicações na instância on-premises
Agora, você está pronto para implantar revisões de aplicativo na instância on-premises registrada e marcada.
Você implementa revisões de aplicativos em instâncias on-premises de uma maneira semelhante à implantação de revisões de aplicativos em instâncias do Amazon EC2. Para instruções, consulte [Crie uma implantação com CodeDeploy](deployments-create.md). Essas instruções incluem um link para pré-requisitos, que incluem: criar um aplicativo, criar um grupo de implantação e preparar uma revisão de aplicativo. Se você precisa de uma simples revisão de aplicativo de amostra para implantar, poderá criar aquela descrito em [Etapa 2: criar uma revisão de aplicativo de amostra](tutorials-on-premises-instance-2-create-sample-revision.md), no [Tutorial: Implantar um aplicativo em uma instância local com CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Importante**
Se você reutilizar uma função de CodeDeploy serviço como parte da criação de um grupo de implantação que tenha como alvo instâncias locais, deverá `Tag:get*` incluí-la na `Action` parte da declaração de política da função de serviço. Para obter mais informações, consulte [Etapa 2: criar uma função de serviço para CodeDeploy](getting-started-create-service-role.md).
## Etapa 8: acompanhar implantações na instância on-premises
Depois de implantar uma revisão de aplicativo em instâncias on-premises registradas e marcadas, você poderá controlar o progresso da implantação.
Você controla as implantações em instâncias on-premises de uma maneira semelhante ao controle de implantações em instâncias do Amazon EC2. Para instruções, consulte [Exibir detalhes CodeDeploy da implantação](deployments-view-details.md).
# Usar o comando register (ARN de usuário do IAM) para registrar uma instância on-premises
**Importante**
O registro de uma instância usando um usuário do IAM não é recomendado porque usa credenciais estáticas (permanentes) para autenticação. Para melhorar a segurança, recomendamos registrar uma instância usando credenciais temporárias para autenticação. Para obter mais informações, consulte [Use o register-on-premises-instance comando (ARN da sessão do IAM) para registrar uma instância local](register-on-premises-instance-iam-session-arn.md).
**Importante**
Certifique-se de ter um plano para alternar as chaves de acesso do usuário do IAM (credenciais permanentes). Para obter mais informações, consulte [Alternando as chaves de acesso](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Esta seção descreve como configurar uma instância local e registrá-la e marcá-la com o CodeDeploy com o mínimo de esforço. O comando **register** é mais útil quando você está trabalhando com frotas únicas ou pequenas de instâncias locais. Você pode usar o comando **register** somente quando está usando um ARN de usuário do IAM para autenticar uma instância. Você não pode usar o comando **register** com um ARN de sessão do IAM para autenticação.
Ao usar o **register** comando, você pode CodeDeploy fazer o seguinte:
+ Crie um usuário do IAM AWS Identity and Access Management para a instância local, se você não especificar um com o comando.
+ Salvar as credenciais do usuário do IAM em um arquivo de configuração da instância on-premises.
+ Registre a instância local com CodeDeploy.
+ Adicione tags à instância local se você as especificar como parte do comando.
**nota**
O [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando é uma alternativa ao comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html). Você usa o comando **register-on-premises-instance** para configurar uma instância local e registrá-la e marcá-la no CodeDeploy principalmente por sua conta. O comando **register-on-premises-instance** também fornece a opção de usar um ARN de sessão do IAM para registrar instâncias em vez de um ARN de usuário do IAM. Essa abordagem proporciona uma grande vantagem quando você tem grandes frotas de instâncias locais. Especificamente, é possível usar um único ARN de sessão do IAM para autenticar várias instâncias em vez de ter que criar um usuário do IAM para cada instância on-premises, uma a uma. Para obter mais informações, consulte [Use o register-on-premises-instance comando (ARN do usuário do IAM) para registrar uma instância local](register-on-premises-instance-iam-user-arn.md) e [Use o register-on-premises-instance comando (ARN da sessão do IAM) para registrar uma instância local](register-on-premises-instance-iam-session-arn.md).
**Topics**
+ [Etapa 1: instalar e configurar o AWS CLI na instância local](#instances-on-premises-register-instance-1-install-cli)
+ [Etapa 2: chamar o comando register](#instances-on-premises-register-instance-2-register-command)
+ [Etapa 3: chamar o comando install](#instances-on-premises-register-instance-3-install-command)
+ [Etapa 4: implantar revisões de aplicações na instância on-premises](#instances-on-premises-register-instance-4-deploy-revision)
+ [Etapa 5: acompanhar implantações na instância on-premises](#instances-on-premises-register-instance-5-track-deployment)
## Etapa 1: instalar e configurar o AWS CLI na instância local
1. Instale o AWS CLI na instância local. Siga as instruções em [Conceitos básicos do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) no *Guia do usuário do AWS Command Line Interface *.
**nota**
CodeDeploy os comandos para trabalhar com instâncias locais estão disponíveis na AWS CLI versão 1.7.19 e posterior. Se você AWS CLI já tiver o instalado, ligue **aws --version** para verificar sua versão.
1. Configure o AWS CLI na instância local. Siga as instruções em [Configuração do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) no *Guia do usuário do AWS Command Line Interface *.
**Importante**
Ao configurar o AWS CLI (por exemplo, chamando o **aws configure** comando), certifique-se de especificar o ID da chave secreta e a chave de acesso secreta de um usuário do IAM que tenha, no mínimo, as seguintes permissões de AWS acesso, além das permissões especificadas em[Pré-requisitos para configurar uma instância on-premises](instances-on-premises-prerequisites.md). Isso possibilita o download e a instalação do CodeDeploy agente na instância local. As permissões de acesso podem parecer semelhantes a estas:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:getTagKeys",
"tag:getTagValues",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Se você ver erros de acesso negado ao tentar acessar um dos buckets do Amazon S3 mostrados anteriormente, tente omitir a parte `/*` do ARN do recurso do bucket, por exemplo, `arn:aws:s3:::aws-codedeploy-sa-east-1`.
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
}
]
}
```
## Etapa 2: chamar o comando register
Para esta etapa, estamos supondo que você esteja registrando a instância local a partir dela mesma. Você também pode registrar uma instância local a partir de um dispositivo ou instância separada que a tenha AWS CLI instalada e configurada conforme descrito na etapa anterior.
Use o AWS CLI para chamar o comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html), especificando:
+ Um nome que identifica de forma exclusiva a instância local para CodeDeploy (com a opção). `--instance-name`
**Importante**
Para ajudar a identificar a instância local, especialmente para fins de depuração, recomendamos que você use um nome que seja mapeado para algumas características exclusivas da instância local (por exemplo, o número de série ou algum identificador de ativo interno exclusivo, se aplicável). Se você especificar um endereço MAC para um nome, saiba que os endereços MAC contêm caracteres que CodeDeploy não são permitidos, como dois pontos (`:`). Para obter uma lista de caracteres permitidos, consulte [CodeDeploy cotas](limits.md).
+ Opcionalmente, o ARN de um usuário do IAM existente que você deseja associar a essa instância on-premises (com a opção `--iam-user-arn`). Para acessar o ARN de um usuário do IAM, chame o comando [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html) ou escolha o nome do usuário do IAM na seção **Usuários** do console do IAM e localize o valor de **ARN do usuário** na seção **Resumo**. Se essa opção não for especificada, CodeDeploy criará um usuário do IAM em seu nome na sua AWS conta e o associará à instância local.
**Importante**
Se você especificar a opção `--iam-user-arn`, também deverá criar manualmente o arquivo de configuração da instância local, conforme descrito em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](register-on-premises-instance-iam-user-arn.md#register-on-premises-instance-iam-user-arn-4).
É possível associar apenas um usuário do IAM a apenas uma instância on-premises. Tentar associar um único usuário do IAM a várias instâncias on-premises pode resultar em erros, implantações com falhas nessas instâncias on-premises ou implantações em instâncias on-premises que estão presas em um estado pendente perpétuo.
+ Opcionalmente, um conjunto de tags de instância local (com a `--tags` opção) que CodeDeploy serão usadas para identificar o conjunto de instâncias do Amazon EC2 nas quais implantar. Especifique cada tag com `Key=tag-key,Value=tag-value` (por exemplo, `Key=Name,Value=Beta Key=Name,Value=WestRegion`). Se essa opção não for especificada, nenhuma tag será registrada. Para registrar as tags posteriormente, chame o comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html).
+ Opcionalmente, a AWS região em que a instância local será registrada CodeDeploy (com a `--region` opção). Essa deve ser uma das regiões compatíveis listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) na *Referência geral da AWS* (por exemplo, `us-west-2`). Se essa opção não for especificada, a AWS região padrão associada ao usuário do IAM chamador será usada.
Por exemplo:
```
aws deploy register --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem --tags Key=Name,Value=CodeDeployDemo-OnPrem --region us-west-2
```
O comando **register** faz o seguinte:
1. Se nenhum usuário existente do IAM for especificado, cria um usuário do IAM, anexa as permissões necessárias a ele e gera uma chave secreta e uma chave de acesso secreta correspondentes. A instância local usará esse usuário do IAM e suas permissões e credenciais para autenticar e interagir com ele. CodeDeploy
1. Registra a instância local com. CodeDeploy
1. Se especificado, associa-se CodeDeploy às tags especificadas com a `--tags` opção com o nome da instância local registrada.
1. Se um usuário do IAM tiver sido criado, também criará o arquivo de configuração necessário no mesmo diretório do qual o comando **register** foi chamado.
Se esse comando encontrar erros, será exibida uma mensagem de erro descrevendo como você pode concluir manualmente as etapas restantes. Caso contrário, será exibida uma mensagem de sucesso, descrevendo como chamar o comando **install**, conforme listado na próxima etapa.
## Etapa 3: chamar o comando install
Na instância local, use o AWS CLI para chamar o comando [install](https://docs.aws.amazon.com/cli/latest/reference/deploy/install.html), especificando:
+ O caminho para o arquivo de configuração (com a opção `--config-file`).
+ Opcionalmente, seja para substituir o arquivo de configuração já existente na instância local (com a opção `--override-config`). Se não for especificado, o arquivo de configuração existente não será substituído.
+ Opcionalmente, a AWS região em que a instância local será registrada CodeDeploy (com a `--region` opção). Essa deve ser uma das regiões compatíveis listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) na *Referência geral da AWS* (por exemplo, `us-west-2`). Se essa opção não for especificada, a AWS região padrão associada ao usuário do IAM chamador será usada.
+ Opcionalmente, um local personalizado a partir do qual instalar o CodeDeploy agente (com a `--agent-installer` opção). Essa opção é útil para instalar uma versão personalizada do CodeDeploy agente que CodeDeploy não oferece suporte oficial (como uma versão personalizada com base no repositório do [CodeDeployagente](https://github.com/aws/aws-codedeploy-agent) GitHub). O valor deve ser o caminho para um bucket do Amazon S3 que contém:
+ Um script de instalação do CodeDeploy agente (para sistemas operacionais baseados em Linux ou UNIX, semelhante ao arquivo de instalação no repositório do [CodeDeployagente](https://github.com/aws/aws-codedeploy-agent/blob/master/bin/install)). GitHub
+ Um arquivo de pacote do instalador do CodeDeploy agente (.msi) (para sistemas operacionais baseados em Windows).
Se essa opção não for especificada, CodeDeploy fará a melhor tentativa de instalar de seu próprio local uma versão oficialmente suportada do CodeDeploy agente que seja compatível com o sistema operacional na instância local.
Por exemplo:
```
aws deploy install --override-config --config-file /tmp/codedeploy.onpremises.yml --region us-west-2 --agent-installer s3://aws-codedeploy-us-west-2/latest/codedeploy-agent.msi
```
O comando **install** faz o seguinte:
1. Verifica se a instância on-premises é uma instância do Amazon EC2. Se for, uma mensagem de erro será exibida.
1. Copia o arquivo de configuração das instâncias locais do local especificado na instância para o local em que o CodeDeploy agente espera encontrá-lo, desde que o arquivo ainda não esteja nesse local.
Para Ubuntu Server e Red Hat Enterprise Linux (RHEL)), isso é`/etc/codedeploy-agent/conf`/`codedeploy.onpremises.yml`.
Para o Windows Server, isso é `C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.
Se a opção `--override-config` tiver sido especificada, criará ou substituirá o arquivo.
1. Instala o CodeDeploy agente na instância local e, em seguida, a inicia.
## Etapa 4: implantar revisões de aplicações na instância on-premises
Agora, você está pronto para implantar revisões de aplicativo na instância on-premises registrada e marcada.
Você implementa revisões de aplicativos em instâncias on-premises de uma maneira semelhante à implantação de revisões de aplicativos em instâncias do Amazon EC2. Para instruções, consulte [Crie uma implantação com CodeDeploy](deployments-create.md). Essas instruções contêm um link para pré-requisitos, que incluem: criar um aplicativo, criar um grupo de implantação e preparar uma revisão de aplicativo. Se você precisa de uma simples revisão de aplicativo de amostra para implantar, poderá criar aquela descrito em [Etapa 2: criar uma revisão de aplicativo de amostra](tutorials-on-premises-instance-2-create-sample-revision.md), no [Tutorial: Implantar um aplicativo em uma instância local com CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Importante**
Se você reutilizar uma função de CodeDeploy serviço existente como parte da criação de um grupo de implantação que tenha como alvo instâncias locais, deverá `Tag:get*` incluí-la na `Action` parte da declaração de política da função de serviço. Para obter mais informações, consulte [Etapa 2: criar uma função de serviço para CodeDeploy](getting-started-create-service-role.md).
## Etapa 5: acompanhar implantações na instância on-premises
Depois de implantar uma revisão de aplicativo em instâncias on-premises registradas e marcadas, você poderá controlar o progresso da implantação.
Você controla as implantações em instâncias on-premises de uma maneira semelhante ao controle de implantações em instâncias do Amazon EC2. Para instruções, consulte [Exibir detalhes CodeDeploy da implantação](deployments-view-details.md).
Para obter mais opções, consulte [Gerenciando operações de instâncias locais em CodeDeploy](on-premises-instances-operations.md).
# Use o register-on-premises-instance comando (ARN do usuário do IAM) para registrar uma instância local
**Importante**
O registro de uma instância usando um usuário do IAM não é recomendado porque usa credenciais estáticas (permanentes) para autenticação. Para melhorar a segurança, recomendamos registrar uma instância usando credenciais temporárias para autenticação. Para obter mais informações, consulte [Use o register-on-premises-instance comando (ARN da sessão do IAM) para registrar uma instância local](register-on-premises-instance-iam-session-arn.md).
**Importante**
Certifique-se de ter um plano para alternar as chaves de acesso do usuário do IAM (credenciais permanentes). Para obter mais informações, consulte [Alternando as chaves de acesso](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Siga essas instruções para configurar uma instância local e registrá-la e marcá-la no CodeDeploy principalmente por conta própria, usando credenciais estáticas de usuário do IAM para autenticação.
**Topics**
+ [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1)
+ [Etapa 2: atribuir permissões ao usuário do IAM](#register-on-premises-instance-iam-user-arn-2)
+ [Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3)
+ [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4)
+ [Etapa 5: instalar e configurar o AWS CLI](#register-on-premises-instance-iam-user-arn-5)
+ [Etapa 6: definir a variável de AWS\$1REGION ambiente (somente Ubuntu Server e RHEL)](#register-on-premises-instance-iam-user-arn-6)
+ [Etapa 7: instalar o CodeDeploy agente](#register-on-premises-instance-iam-user-arn-7)
+ [Etapa 8: registrar a instância local com CodeDeploy](#register-on-premises-instance-iam-user-arn-8)
+ [Etapa 9: marcar a instância on-premises](#register-on-premises-instance-iam-user-arn-9)
+ [Etapa 10: implantar revisões de aplicações na instância on-premises](#register-on-premises-instance-iam-user-arn-10)
+ [Etapa 11: acompanhar implantações na instância on-premises](#register-on-premises-instance-iam-user-arn-11)
## Etapa 1: criar um usuário do IAM para a instância on-premises
Crie um usuário do IAM que a instância local usará para autenticar e interagir. CodeDeploy
**Importante**
Você deve criar um usuário do IAM separado para cada instância on-premises participante. Se você tentar reutilizar um usuário individual do IAM para várias instâncias locais, talvez não consiga registrar ou marcar com êxito essas instâncias locais. CodeDeploy As implementações nessas instâncias locais podem estar presas em um estado pendente perpétuo ou podem falhar completamente.
Recomendamos que você atribua ao usuário do IAM um nome que identifique sua finalidade, como CodeDeployUser -OnPrem.
Você pode usar o console do IAM AWS CLI ou o console para criar um usuário do IAM. Para obter informações, consulte [Criação de um usuário do IAM na sua conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
**Importante**
Se você usa o console do IAM AWS CLI ou o console do IAM para criar um novo usuário do IAM, anote o ARN do usuário fornecido para o usuário. Você precisará dessas informações mais tarde em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4) e [Etapa 8: registrar a instância local com CodeDeploy](#register-on-premises-instance-iam-user-arn-8).
## Etapa 2: atribuir permissões ao usuário do IAM
Se a instância on-premises for implantar revisões de aplicativos de buckets do Amazon S3, será necessário atribuir ao usuário do IAM as permissões para interagir com esses buckets. Você pode usar o console AWS CLI ou o IAM para atribuir permissões.
**nota**
Se você estiver implantando revisões de aplicativos somente de GitHub repositórios, pule esta etapa e vá diretamente para. [Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3) (Você ainda precisará das informações sobre o usuário do IAM criado em [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1). Elas serão usadas em etapas posteriores.)
**Para atribuir permissões (CLI)**
1. Crie um arquivo com o seguinte conteúdo de política na instância do Amazon EC2 ou no dispositivo que você está usando para chamar a AWS CLI. Nomeie o arquivo de algo como **CodeDeploy-OnPrem-Permissions.json** e, em seguida, salve-o.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**nota**
Recomendamos que você restrinja essa política somente para os buckets do Amazon S3 que a sua instância on-premises precisa acessar. Se você restringir essa política, certifique-se de também conceder acesso aos buckets do Amazon S3 que contêm o agente. AWS CodeDeploy Caso contrário, poderá ocorrer um erro sempre que o CodeDeploy agente for instalado ou atualizado na instância local associada.
Por exemplo:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
1. Chame o [put-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-user-policy.html)comando, especificando o nome do usuário do IAM (com a `--user-name` opção), um nome para a política (com a `--policy-name` opção) e o caminho para o documento de política recém-criado (com a `--policy-document` opção). Por exemplo, supondo que o arquivo **CodeDeploy-OnPrem-Permissions.json** esteja no mesmo diretório (pasta) a partir do qual você está chamando esse comando:
**Importante**
Não se esqueça de incluir `file://` antes do nome de arquivo. Ele é obrigatório nesse comando.
```
aws iam put-user-policy --user-name CodeDeployUser-OnPrem --policy-name CodeDeploy-OnPrem-Permissions --policy-document file://CodeDeploy-OnPrem-Permissions.json
```
**Para atribuir permissões (console)**
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 **Policies** e, em seguida, **Create Policy**. (Se aparecer um botão **Get Started**, selecione-o e, em seguida, **Create Policy**.)
1. Próximo a **Create Your Own Policy**, escolha **Select**.
1. Na caixa **Policy Name (Nome da política)**, digite um nome para essa política (por exemplo, **CodeDeploy-OnPrem-Permissions**).
1. Na caixa **Documento de política**, digite ou cole a seguinte expressão de permissões, que permite AWS CodeDeploy implantar revisões de aplicativos de qualquer bucket do Amazon S3 especificado na política para a instância local em nome do usuário do IAM:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
1. Escolha **Create Policy**.
1. No painel de navegação, escolha **Users**.
1. Na lista de usuários, vá até o nome do usuário do IAM que você criou em [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) e escolha-o em seguida.
1. Na guia **Permissões**, em **Políticas gerenciadas**, escolha **Anexar política**.
1. Selecione a política chamada **CodeDeploy-OnPrem-Permissions** e, em seguida, escolha **Attach Policy (Anexar política)**.
## Etapa 3: obter as credenciais do usuário do IAM
Obtenha o ID de chave secreta e a chave de acesso secreta para o usuário do IAM. Você precisará deles para [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4). Você pode usar o console AWS CLI ou o IAM para obter o ID da chave secreta e a chave de acesso secreta.
**nota**
Se você já tem o ID de chave secreta e a chave de acesso secreta, pula etapa e vá diretamente para [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4).
Os usuários precisam de acesso programático se quiserem interagir com pessoas AWS fora do Console de gerenciamento da AWS. A forma de conceder acesso programático depende do tipo de usuário que está acessando AWS.
Para conceder acesso programático aos usuários, selecione uma das seguintes opções:
****
| Qual usuário precisa de acesso programático? | Para | Por |
| --- | --- | --- |
| IAM | (Recomendado) Use as credenciais do console como credenciais temporárias para assinar solicitações programáticas para o AWS CLI, AWS SDKs ou. AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| Identidade da força de trabalho (Usuários gerenciados no Centro de Identidade do IAM) | Use credenciais temporárias para assinar solicitações programáticas para o AWS CLI AWS SDKs, ou. AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| IAM | Use credenciais temporárias para assinar solicitações programáticas para o AWS CLI AWS SDKs, ou. AWS APIs | Siga as instruções em [Como usar credenciais temporárias com AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no Guia do usuário do IAM. |
| IAM | (Não recomendado)Use credenciais de longo prazo para assinar solicitações programáticas para o AWS CLI, AWS SDKs, ou. AWS APIs | Siga as instruções da interface que deseja utilizar. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
**Para obter as credenciais (CLI)**
1. Chame o [list-access-keys](https://docs.aws.amazon.com/cli/latest/reference/iam/list-access-keys.html)comando, especificando o nome do usuário do IAM (com a `--user-name` opção) e consultando apenas a chave de acesso IDs (com as `--output` opções `--query` e). Por exemplo:
```
aws iam list-access-keys --user-name CodeDeployUser-OnPrem --query "AccessKeyMetadata[*].AccessKeyId" --output text
```
1. Se nenhuma chave aparecer na saída ou as informações sobre apenas uma chave aparecerem na saída, chame o [create-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)comando, especificando o nome do usuário do IAM (com a `--user-name` opção):
```
aws iam create-access-key --user-name CodeDeployUser-OnPrem
```
Na saída da chamada para o comando **create-access-key**, anote os valores dos campos `AccessKeyId` e `SecretAccessKey`. Você precisará dessas informações em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4).
**Importante**
Esta será a única vez que você terá acesso a essa chave de acesso secreta. Se você esquecer ou perder o acesso a essa chave de acesso secreta, precisará gerar uma nova, seguindo as etapas em [Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3).
1. Se duas chaves de acesso já estiverem listadas, você deverá excluir uma delas chamando o [delete-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html)comando, especificando o nome do usuário do IAM (com a `--user-name` opção) e o ID da chave de acesso a ser excluída (com a `--access-key-id` opção). Em seguida, chame o comando **create-access-key**, conforme descrito anteriormente nessa etapa. Aqui está um exemplo de como chamar o comando **delete-access-key**:
```
aws iam delete-access-key --user-name CodeDeployUser-OnPrem --access-key-id access-key-ID
```
**Importante**
Se você chamar o comando **delete-access-key** para excluir uma dessas chaves de acesso, e uma instância on-premises já estiver usando essa chave de acesso conforme descrito em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4), será necessário seguir novamente as instruções em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4) para especificar um ID de chave de acesso diferente e a chave de acesso secreta associada a esse usuário do IAM. Caso contrário, quaisquer implementações nessa instância local poderão ficar presas em um estado pendente perpétuo ou falhar completamente.
**Para obter as credenciais (console)**
1.
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Se a lista de usuários não for exibida, no painel de navegação, escolha **Usuários**.
1. Na lista de usuários, vá até o nome do usuário do IAM que você criou em [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) e escolha-o em seguida.
1. Na guia **Credenciais de segurança**, se nenhuma chave ou apenas uma chave for listada, escolha **Criar chave de acesso**.
Se duas chaves de acesso estiverem listadas, você deverá excluir uma delas. Escolha **Excluir** ao lado de uma das chaves de acesso e, em seguida, escolha **Criar chave de acesso**.
**Importante**
Se você escolher **Excluir** ao lado de uma dessas chaves de acesso, e uma instância on-premises já estiver usando essa chave de acesso conforme descrito em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4), você precisará seguir novamente as instruções em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4) para especificar um ID de chave de acesso diferente e a chave de acesso secreta associada a esse usuário do IAM. Caso contrário, as implementações nessa instância local poderão ficar presas em um estado pendente perpétuo ou falhar completamente.
1. Escolha **Mostrar** e anote o ID de chave de acesso e a chave de acesso secreta. Você precisará dessas informações para a próxima etapa. Como alternativa, você pode escolher **Fazer download do arquivo .csv** para salvar uma cópia do ID de chave de acesso e da chave de acesso secreta.
**Importante**
A menos que você anote ou baixe as credenciais, este será seu único acesso a essa chave de acesso secreta. Se você esquecer ou perder o acesso a essa chave de acesso secreta, precisará gerar uma nova, seguindo as etapas em [Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3).
1. Escolha **Fechar** para retornar à *IAM User Name* página **Usuários >**.
## Etapa 4: adicionar um arquivo de configuração à instância on-premises
Adicione um arquivo de configuração à instância on-premises usando permissões raiz ou de administrador. Esse arquivo de configuração será usado para declarar as credenciais do usuário do IAM e a AWS região de destino para a qual será usada. CodeDeploy O arquivo deve ser adicionado a um local específico na instância on-premises. O arquivo deve incluir o ARN do usuário do IAM, o ID da chave secreta, a chave de acesso secreta e a região de destino AWS . O arquivo deve seguir um formato específico.
1. Crie um arquivo chamado `codedeploy.onpremises.yml` (para uma instância on-premises do Ubuntu Server ou do RHEL) ou `conf.onpremises.yml` (para uma instância on-premises do Windows Server) na seguinte localização da instância on-premises:
+ Para Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Para Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Use um editor de texto para adicionar as seguintes informações ao arquivo `codedeploy.onpremises.yml` ou `conf.onpremises.yml` recém-criado:
```
---
aws_access_key_id: secret-key-id
aws_secret_access_key: secret-access-key
iam_user_arn: iam-user-arn
region: supported-region
```
Em que:
+ *secret-key-id*é o ID da chave secreta correspondente do usuário do IAM que você [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) anotou em ou[Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3).
+ *secret-access-key*é a chave de acesso secreta correspondente do usuário do IAM que você [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) anotou em ou[Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3).
+ *iam-user-arn*é o ARN do usuário do IAM que você anotou anteriormente. [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1)
+ *supported-region*é o identificador de uma região suportada pela CodeDeploy localização de seus CodeDeploy aplicativos, grupos de implantação e revisões de aplicativos (por exemplo,`us-west-2`). Para obter uma lista de regiões, consulte [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region), na *Referência geral da AWS*.
**Importante**
Se você escolheu **Excluir** ao lado de uma das chaves de acesso em [Etapa 3: obter as credenciais do usuário do IAM](#register-on-premises-instance-iam-user-arn-3) e sua instância on-premises já estiver usando o ID da chave de acesso e a chave de acesso secreta associados, será necessário seguir as instruções em [Etapa 4: adicionar um arquivo de configuração à instância on-premises](#register-on-premises-instance-iam-user-arn-4) para especificar um ID de chave de acesso e uma chave de acesso secreta diferentes associados a esse usuário do IAM. Caso contrário, quaisquer implementações na sua instância local poderão ficar presas em um estado pendente perpétuo ou falhar completamente.
## Etapa 5: instalar e configurar o AWS CLI
Instale e configure o AWS CLI na instância local. (Eles AWS CLI serão usados [Etapa 7: instalar o CodeDeploy agente](#register-on-premises-instance-iam-user-arn-7) para baixar e instalar o CodeDeploy agente na instância local.)
1. Para instalar o AWS CLI na instância local, siga as instruções em [Como configurar com o AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) no *Guia do AWS Command Line Interface usuário*.
**nota**
CodeDeploy comandos para trabalhar com instâncias locais foram disponibilizados na versão 1.7.19 do. AWS CLI Se você tiver uma versão do AWS CLI já instalada, poderá verificar sua versão ligando para**aws --version**.
1. Para configurar o AWS CLI na instância local, siga as instruções em [Configurando o AWS CLI no Guia](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) do *AWS Command Line Interface usuário*.
**Importante**
Ao configurar o AWS CLI (por exemplo, chamando o **aws configure** comando), certifique-se de especificar o ID da chave secreta e a chave de acesso secreta de um usuário do IAM que tenha, no mínimo, as seguintes permissões de AWS acesso, além das permissões de acesso especificadas no[Pré-requisitos para configurar uma instância on-premises](instances-on-premises-prerequisites.md). Isso possibilita que você baixe e instale o CodeDeploy agente na instância local:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"*"
]
}
]
}
```
Essas permissões de acesso podem ser atribuídas ao usuário do IAM que você criou em [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) ou a um usuário do IAM diferente. Para atribuir essas permissões a um usuário do IAM, siga as instruções em [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) usando essas permissões de acesso em vez das especificadas nesta etapa.
## Etapa 6: definir a variável de AWS\$1REGION ambiente (somente Ubuntu Server e RHEL)
Se não estiver executando o Ubuntu Server ou o RHEL na sua instância on-premises, ignore esta etapa e vá diretamente para [Etapa 7: instalar o CodeDeploy agente](#register-on-premises-instance-iam-user-arn-7).
Instale o CodeDeploy agente em uma instância local do Ubuntu Server ou do RHEL e permita que a instância atualize o CodeDeploy agente sempre que uma nova versão estiver disponível. Isso é feito configurando a variável de ambiente `AWS_REGION` na instância como o identificador de uma das regiões com suporte pelo CodeDeploy. Recomendamos que você defina o valor para a região em que seus CodeDeploy aplicativos, grupos de implantação e revisões de aplicativos estão localizados (por exemplo,`us-west-2`). Para obter uma lista de regiões, consulte [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region), na *Referência geral da AWS*.
Para definir a variável de ambiente, chame o seguinte usando o terminal:
```
export AWS_REGION=supported-region
```
Onde *supported-region* está o identificador da região (por exemplo,`us-west-2`).
## Etapa 7: instalar o CodeDeploy agente
Instale o CodeDeploy agente na instância local:
+ Para uma instância on-premises do Ubuntu Server, siga as instruções em [Instale o CodeDeploy agente para o Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md) e depois retorne a esta página.
+ Para uma instância on-premises do RHEL, siga as instruções em [Instale o CodeDeploy agente para Amazon Linux ou RHEL](codedeploy-agent-operations-install-linux.md) e depois retorne a esta página.
+ Para uma instância on-premises do Windows Server, siga as instruções em [Instale o CodeDeploy agente para Windows Server](codedeploy-agent-operations-install-windows.md) e depois retorne a esta página.
## Etapa 8: registrar a instância local com CodeDeploy
As instruções nesta etapa supõem que você esteja registrando a instância on-premises a partir dela mesma. Você pode registrar uma instância local a partir de um dispositivo ou instância separada que a tenha AWS CLI instalada e configurada, conforme descrito em[Etapa 5: instalar e configurar o AWS CLI](#register-on-premises-instance-iam-user-arn-5).
Use o AWS CLI para registrar a instância local CodeDeploy para que ela possa ser usada em implantações.
1. Antes de usar o AWS CLI, você precisará do ARN do usuário do IAM em que você criou. [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) Se você ainda não possui o ARN do usuário, chame o comando [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html), especificando o nome do usuário do IAM (com a opção `--user-name`) e consultando o ARN do usuário (com as opções `--query` e `--output`):
```
aws iam get-user --user-name CodeDeployUser-OnPrem --query "User.Arn" --output text
```
1. Use o comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html), especificando:
+ Um nome que identifique de forma exclusiva a instância on premises (com a opção `--instance-name`).
**Importante**
Para ajudar a identificar a instância local, especialmente para fins de depuração, recomendamos que você especifique um nome que seja mapeado para alguma característica exclusiva da instância local (por exemplo, o número de série ou um identificador interno de ativo, se aplicável). Se você especificar um endereço MAC como nome, saiba que os endereços MAC contêm caracteres que CodeDeploy não são permitidos, como dois pontos (`:`). Para obter uma lista de caracteres permitidos, consulte [CodeDeploy cotas](limits.md).
+ O ARN do usuário do IAM que você criou em [Etapa 1: criar um usuário do IAM para a instância on-premises](#register-on-premises-instance-iam-user-arn-1) (com a opção `--iam-user-arn`).
Por exemplo:
```
aws deploy register-on-premises-instance --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem
```
## Etapa 9: marcar a instância on-premises
Você pode usar o console AWS CLI ou o CodeDeploy console para marcar a instância local. (CodeDeployusa tags de instância local para identificar os alvos de implantação durante uma implantação.)
**Para marcar a instância on-premises (CLI)**
+ Chame o comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html), especificando:
+ O nome que identifica de forma exclusiva a instância on-premises (com a opção `--instance-names`).
+ O nome da chave da tag de instância on-premises e o valor da tag que você deseja usar (com a opção `--tags`). Você deve especificar um nome e um valor. CodeDeploy não permite tags de instância local que tenham somente valores.
Por exemplo:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Para marcar a instância on-premises (console)**
1. Faça login no Console de gerenciamento da AWS e abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Faça login com o mesmo usuário que você configurou em [Começando com CodeDeploy](getting-started-codedeploy.md).
1. CodeDeploy No menu, escolha **Instâncias locais**.
1. Na lista de instâncias locais, escolha a seta ao lado da instância local que você deseja marcar.
1. Na lista de tags, selecione ou insira a chave e o valor da tag desejados. Após inserir a chave e o valor da tag, outra linha será exibida. Isso pode ser repetido para até 10 tags. Para remover uma tag, selecione o ícone de exclusão (![\[The delete icon.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/delete-triggers-x.png)).
1. Depois de adicionar as tags, escolha **Atualizar tags**.
## Etapa 10: implantar revisões de aplicações na instância on-premises
Agora, você está pronto para implantar revisões de aplicativo na instância on-premises registrada e marcada.
Você implementa revisões de aplicativos em instâncias on-premises de uma maneira semelhante à implantação de revisões de aplicativos em instâncias do Amazon EC2. Para instruções, consulte [Crie uma implantação com CodeDeploy](deployments-create.md). Essas instruções incluem um link para pré-requisitos, que incluem: criar um aplicativo, criar um grupo de implantação e preparar uma revisão de aplicativo. Se você precisa de uma simples revisão de aplicativo de amostra para implantar, poderá criar aquela descrito em [Etapa 2: criar uma revisão de aplicativo de amostra](tutorials-on-premises-instance-2-create-sample-revision.md), no [Tutorial: Implantar um aplicativo em uma instância local com CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Importante**
Se você reutilizar uma função de CodeDeploy serviço como parte da criação de um grupo de implantação que tenha como alvo instâncias locais, deverá `Tag:get*` incluí-la na `Action` parte da declaração de política da função de serviço. Para obter mais informações, consulte [Etapa 2: criar uma função de serviço para CodeDeploy](getting-started-create-service-role.md).
## Etapa 11: acompanhar implantações na instância on-premises
Depois de implantar uma revisão de aplicativo em instâncias on-premises registradas e marcadas, você poderá controlar o progresso da implantação.
Você controla as implantações em instâncias on-premises de uma maneira semelhante ao controle de implantações em instâncias do Amazon EC2. Para instruções, consulte [Exibir detalhes CodeDeploy da implantação](deployments-view-details.md).
# Gerenciando operações de instâncias locais em CodeDeploy
Siga as instruções nesta seção para gerenciar as operações em suas instâncias locais depois de registrá-las CodeDeploy, como obter mais informações, remover tags, desinstalar e cancelar o registro de instâncias locais.
**Topics**
+ [Obter informações sobre uma única instância on-premises](on-premises-instances-operations-view-details-single.md)
+ [Obter informações sobre várias instâncias on-premises](on-premises-instances-operations-view-details-multiple.md)
+ [Remover manualmente tags de instância local de uma instância on-premises](on-premises-instances-operations-remove-tags.md)
+ [Desinstale automaticamente o CodeDeploy agente e remova o arquivo de configuração de uma instância local](on-premises-instances-operations-uninstall-agent.md)
+ [Cancelar automaticamente o registro de uma instância on-premises](on-premises-instances-operations-deregister-automatically.md)
+ [Cancelar manualmente o registro de uma instância on-premises](on-premises-instances-operations-deregister-manually.md)
# Obter informações sobre uma única instância on-premises
Você pode obter informações sobre uma única instância local, seguindo as instruções em [Exibir detalhes CodeDeploy da implantação](deployments-view-details.md). Você pode usar o console AWS CLI ou o CodeDeploy console para obter mais informações sobre uma única instância local.
**Para obter informações sobre uma única instância local (CLI)**
+ Chame o comando [get-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-on-premises-instance.html), especificando o nome que identifica as instâncias no local (com a opção `--instance-name`):
```
aws deploy get-on-premises-instance --instance-name AssetTag12010298EX
```
**Para obter informações sobre uma única instância local (console)**
1. Faça login no Console de gerenciamento da AWS e abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Faça login com o mesmo usuário que você configurou em [Começando com CodeDeploy](getting-started-codedeploy.md).
1. No painel de navegação, expanda **Implantar** e escolha **Instâncias on-premises**.
1. Na lista de instâncias no local, escolha a nome de um nas instâncias locais para visualizar seus detalhes.
# Obter informações sobre várias instâncias on-premises
Você pode obter informações sobre instâncias locais seguindo as instruções em [Exibir detalhes CodeDeploy da implantação](deployments-view-details.md). Você pode usar o console AWS CLI ou o CodeDeploy console para obter mais informações sobre instâncias locais.
**Para obter informações sobre várias instâncias locais (CLI)**
1. Para obter uma lista de nomes de instâncias locais, chame o comando [list-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-on-premises-instances.html), especificando:
+ Seja para obter informações sobre todas as instâncias locais com ou sem registro (com a opção `--registration-status` e `Registered` ou `Deregistered`, respectivamente). Se você omitir isso, nomes de instâncias com ou sem registro serão retornados.
+ Seja para obter informações apenas sobre instâncias locais marcadas com tags de instância local específicas (com a opção `--tag-filters`). Para cada tag de instância local, especifique `Key`, `Value` e `Type` (que sempre deve ser `KEY_AND_VALUE`). Separe várias marcas de instância local com espaços entre cada tripleto `Key`, `Value` e `Type`.
Por exemplo:
```
aws deploy list-on-premises-instances --registration-status Registered --tag-filters Key=Name,Value=CodeDeployDemo-OnPrem,Type=KEY_AND_VALUE Key=Name,Value=CodeDeployDemo-OnPrem-Beta,Type=KEY_AND_VALUE
```
1. Para obter informações mais detalhadas, chame o comando [batch-get-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-on-premises-instances.html), com os nomes das instâncias locais (com a `--instance-names` opção):
```
aws deploy batch-get-on-premises-instances --instance-names AssetTag12010298EX AssetTag09920444EX
```
**Para obter informações sobre várias instâncias locais (console)**
1. Faça login no Console de gerenciamento da AWS e abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Faça login com o mesmo usuário que você configurou em [Começando com CodeDeploy](getting-started-codedeploy.md).
1. No painel de navegação, expanda **Implantar** e escolha **Instâncias on-premises**.
Informações sobre as instâncias locais são exibidas.
# Remover manualmente tags de instância local de uma instância on-premises
Normalmente, você remove uma tag de instância local de uma instância local quando essa tag não está mais sendo usada ou quando você deseja remover a instância local de qualquer grupo de implantação que dependa dessa tag. Você pode usar o console AWS CLI ou o AWS CodeDeploy console para remover as tags de instância local das instâncias locais.
Você não precisa remover as tags de instância local de uma instância local antes de cancelar o registro de instância.
A remoção manual de tags de instância local de uma instância local não cancela o registro dessa instância. Ele não desinstala o CodeDeploy agente da instância. Ele não remove o arquivo de configuração da instância. Ele não exclui o usuário do IAM associado à instância.
Para cancelar automaticamente o registro da instância on-premises, consulte [Cancelar automaticamente o registro de uma instância on-premises](on-premises-instances-operations-deregister-automatically.md).
Para cancelar manualmente o registro da instância on-premises, consulte [Cancelar manualmente o registro de uma instância on-premises](on-premises-instances-operations-deregister-manually.md).
Para desinstalar automaticamente o CodeDeploy agente e remover o arquivo de configuração da instância local, consulte[Desinstale automaticamente o CodeDeploy agente e remova o arquivo de configuração de uma instância local](on-premises-instances-operations-uninstall-agent.md).
Para desinstalar manualmente somente o CodeDeploy agente da instância local, consulte[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md).
Para excluir manualmente o usuário do IAM associado, consulte [Excluir um usuário do IAM da sua conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
**Para remover tags de instância local de uma instância no local (CLI)**
+ Chame as [remove-tags-from-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/remove-tags-from-on-premises-instances.html), especificando:
+ Os nomes que identificam de forma exclusiva a instância local (com a opção `--instance-names`).
+ Os nomes e valores das tags que você deseja remover (com a opção `--tags`).
Por exemplo:
```
aws deploy remove-tags-from-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Para remover tags de instância local de uma instância no local (console)**
1. Faça login no Console de gerenciamento da AWS e abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Faça login com o mesmo usuário que você configurou em [Começando com CodeDeploy](getting-started-codedeploy.md).
1. No painel de navegação, expanda **Implantar** e escolha **Instâncias on-premises**.
1. Na lista de instâncias locais, escolha a nome da instância no local da qual você deseja remover tags.
1. Nas seções **Tags**, escolha **Remove (Remover)** próximo a cada tag que você deseja remover.
1. Depois de excluir as tags, escolha **Atualizar tags**.
# Desinstale automaticamente o CodeDeploy agente e remova o arquivo de configuração de uma instância local
Normalmente, você desinstala o CodeDeploy agente e remove o arquivo de configuração de uma instância local depois de não planejar mais implantá-la.
**nota**
A desinstalação automática do CodeDeploy agente e a remoção do arquivo de configuração de uma instância local não cancela o registro de uma instância local. Ele não desassocia nenhuma tag de instância local associada à instância local. Ele não exclui o usuário do IAM associado à instância on-premises.
Para cancelar automaticamente o registro da instância on-premises, consulte [Cancelar automaticamente o registro de uma instância on-premises](on-premises-instances-operations-deregister-automatically.md).
Para cancelar manualmente o registro da instância on-premises, consulte [Cancelar manualmente o registro de uma instância on-premises](on-premises-instances-operations-deregister-manually.md).
Para desassociar manualmente qualquer tag de instância on-premises associada, consulte [Remover manualmente tags de instância local de uma instância on-premises](on-premises-instances-operations-remove-tags.md).
Para desinstalar manualmente o CodeDeploy agente da instância local, consulte[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md).
Para excluir manualmente o usuário do IAM associado, consulte [Excluir um usuário do IAM da sua conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Na instância local, use o AWS CLI para chamar o comando [uninstall](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html).
Por exemplo:
```
aws deploy uninstall
```
O comando **uninstall** faz o seguinte:
1. Interrompe a execução do CodeDeploy agente na instância local.
1. Desinstala o CodeDeploy agente da instância local.
1. Remove o arquivo de configuração da instância local. (Para o Ubuntu Server e o RHEL, isso é `/etc/codedeploy-agent/conf`/`codedeploy.onpremises.yml`. Para o Windows Server, isso é `C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.)
# Cancelar automaticamente o registro de uma instância on-premises
Normalmente, você cancela o registro de uma instância on-premises quando não planeja mais implantá-la. Quando você cancela o registro de uma instância local, mesmo que essa instância local possa fazer parte das tags de instância local de um grupo de implantação, ela não é incluída em nenhuma implantação. Você pode usar o AWS CLI para cancelar o registro de instâncias locais.
**nota**
Você não pode usar o CodeDeploy console para cancelar o registro de uma instância local. Além disso, cancelar o registro de uma instância no local remove qualquer tag de instância no local que esteja associada à instância no local. Ele não desinstala o CodeDeploy agente da instância local. Ele não remove o arquivo de configuração da instância local.
Para usar o CodeDeploy console para realizar algumas (mas não todas) as atividades desta seção, consulte a seção CodeDeploy console do[Cancelar manualmente o registro de uma instância on-premises](on-premises-instances-operations-deregister-manually.md).
Para desassociar manualmente qualquer tag de instância on-premises associada, consulte [Remover manualmente tags de instância local de uma instância on-premises](on-premises-instances-operations-remove-tags.md).
Para desinstalar automaticamente o CodeDeploy agente e remover o arquivo de configuração da instância local, consulte[Desinstale automaticamente o CodeDeploy agente e remova o arquivo de configuração de uma instância local](on-premises-instances-operations-uninstall-agent.md).
Para desinstalar manualmente somente o CodeDeploy agente da instância local, consulte[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md).
Use o AWS CLI para chamar o comando de [cancelamento de registro](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html), especificando:
+ O nome que identifica de forma exclusiva a instância local para CodeDeploy (com a opção). `--instance-name`
+ Opcionalmente, se deseja excluir o usuário do IAM associado à instância on-premises. O comportamento padrão é excluir o usuário do IAM. Se não quiser excluir o usuário do IAM associado à instância no local, especifique a opção `--no-delete-iam-user` no comando.
+ Opcionalmente, a AWS região em que a instância local foi registrada CodeDeploy (com a `--region` opção). Esta deve ser uma das regiões compatíveis listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) na *Referência geral da AWS* (por exemplo, `us-west-2`). Se essa opção não for especificada, a AWS região padrão associada ao usuário do IAM chamador será usada.
Um exemplo que cancela o registro de uma instância e exclui o usuário:
```
aws deploy deregister --instance-name AssetTag12010298EX --region us-west-2
```
Um exemplo que cancela o registro de uma instância e não exclui o usuário:
```
aws deploy deregister --instance-name AssetTag12010298EX --no-delete-iam-user --region us-west-2
```
O comando **deregister** faz o seguinte:
1. Cancela o registro da instância local com. CodeDeploy
1. Se especificado, exclui o usuário do IAM associado à instância on-premises.
Depois de cancelar o registro de uma instância on-premises:
+ Ela não é mais exibida no console imediatamente.
+ Você pode criar outra instância com o mesmo nome imediatamente.
Se esse comando encontrar erros, será exibida uma mensagem de erro descrevendo como você pode concluir manualmente as etapas restantes. Caso contrário, será exibida uma mensagem de sucesso, descrevendo como chamar o comando **uninstall**.
# Cancelar manualmente o registro de uma instância on-premises
Normalmente, você cancela o registro de uma instância on-premises quando não planeja mais implantá-la. Você usa o AWS CLI para cancelar manualmente o registro de instâncias locais.
O cancelamento manual do registro de uma instância local não desinstala o agente. CodeDeploy Ele não remove o arquivo de configuração da instância. Ele não exclui o usuário do IAM associado à instância. Ele não remove tags associadas à instância.
Para desinstalar automaticamente o CodeDeploy agente e remover o arquivo de configuração da instância local, consulte[Desinstale automaticamente o CodeDeploy agente e remova o arquivo de configuração de uma instância local](on-premises-instances-operations-uninstall-agent.md).
Para desinstalar manualmente somente o CodeDeploy agente, consulte[Gerenciando as operações CodeDeploy do agente](codedeploy-agent-operations.md).
Para excluir manualmente o usuário do IAM associado, consulte [Excluir um usuário do IAM da sua conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Para remover manualmente apenas as tags de instância local associadas, consulte [Remover manualmente tags de instância local de uma instância on-premises](on-premises-instances-operations-remove-tags.md).
+ Chame o comando [deregister-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister-on-premises-instance.html), especificando o nome que identifica as instâncias no local (com a opção `--instance-name`):
```
aws deploy deregister-on-premises-instance --instance-name AssetTag12010298EX
```
Depois de cancelar o registro de uma instância on-premises:
+ Ela não é mais exibida no console imediatamente.
+ Você pode criar outra instância com o mesmo nome imediatamente.
# Visualizar detalhes da instância com o CodeDeploy
Você pode usar o console do CodeDeploy, o AWS CLI ou as APIs do CodeDeploy para visualizar detalhes sobre instâncias usadas em uma implantação.
Para obter informações sobre como usar ações da API do CodeDeploy para visualizar instâncias, consulte [GetDeploymentInstance](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GetDeploymentInstance.html), [ListDeploymentInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListDeploymentInstances.html) e [ListOnPremisesInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListOnPremisesInstances.html).
**Topics**
+ [Exibir detalhes da instância (console)](#instances-view-details-console)
+ [Exibir detalhes da instância (CLI)](#instances-view-details-cli)
## Exibir detalhes da instância (console)
Para visualizar os detalhes da instância:
1. Faça login no Console de gerenciamento da AWS e abra o console do CodeDeploy em [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Faça login com o mesmo usuário que você configurou em [Começando com CodeDeploy](getting-started-codedeploy.md).
1. No painel de navegação, expanda a opção **Implantar** e escolha **Implantações**.
**nota**
Se nenhuma entrada for exibida, verifique se a região correta está selecionada. Na barra de navegação, no seletor de região, escolha uma das regiões listadas em [Região e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region), no *Referência geral da AWS*. O CodeDeploy tem suporte somente nessas regiões.
1. Para visualizar os detalhes da implantação, escolha o ID de implantação da instância.
1. Visualize todas as instâncias na seção **Instance activity (Atividade da instância)** da página de implantação.
1. Para ver informações sobre eventos de ciclo de vida de implantação individuais para uma instância, na página de detalhes da implantação, na coluna **Eventos**, escolha **Exibir eventos**.
**nota**
Se **Falha** for exibido para qualquer um dos eventos de ciclo de vida, na página de detalhes da instância, escolha **Exibir logs**, **Exibir no EC2** ou ambos. Você pode encontrar dicas de solução de problemas em [Solução de problemas de instância](troubleshooting-ec2-instances.md).
1. Se quiser ver mais informações sobre uma instância do Amazon EC2, selecione o ID da instância na coluna **ID da instância**.
## Exibir detalhes da instância (CLI)
Para usar a AWS CLI para visualizar detalhes da instância, chame o comando `get-deployment-instance` ou `list-deployment-instances`.
Para visualizar detalhes sobre uma única instância, chame o comando [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html), especificando:
+ O ID de implantação exclusivo. Para obter o ID de implantação, chame o comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ O ID de instância exclusivo. Para obter o ID de instância, chame o comando [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html).
Para ver uma lista de IDs para instâncias usadas em uma implantação, chame o comando [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html), especificando:
+ O ID de implantação exclusivo. Para obter o ID de implantação, chame o comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ Opcionalmente, se você deseja incluir apenas IDs de instâncias específicos por seu status de implantação. (Se não for especificado, todos os IDs de instância correspondentes serão listados, independentemente do status de implantação.)
# CodeDeploy integridade da instância
CodeDeploy monitora o status de integridade das instâncias em um grupo de implantação. Ele reprovará as implantações se o número de instâncias íntegras cair abaixo do número mínimo de instâncias íntegras que foram especificadas para o grupo de implantação durante uma implantação. Por exemplo, se 85% das instâncias precisarem permanecer íntegras durante uma implantação e o grupo de implantação contiver 10 instâncias, a implantação geral falhará se a implementação em uma única instância falhar. Isso ocorre porque, quando uma instância é desconectada para que a última revisão de aplicativo possa ser instalada, a contagem de instâncias íntegras disponíveis já cai para 90%. Uma instância com falha mais outra instância offline significaria que apenas 80% das instâncias estão íntegras e disponíveis. O CodeDeploy falharia a implantação geral.
É importante recordar que a implantação total terá sucesso se os itens a seguir forem alcançados:
+ CodeDeploy é capaz de implantar em cada instância na implantação.
+ A implantação em pelo menos uma instância precisa ser bem-sucedida. Isso significa que, mesmo se o valor mínimo de hosts íntegros for 0, a implantação em pelo menos uma instância deve ser bem-sucedida, ou seja, no mínimo uma instância precisa estar íntegra. Dessa maneira, a implantação geral será bem-sucedida.
**Topics**
+ [Status de integridade](#instances-health-status)
+ [Sobre o número mínimo de instâncias íntegras](#minimum-healthy-hosts)
+ [Sobre o número mínimo de instâncias íntegras por zona de disponibilidade.](#minimum-healthy-hosts-az)
## Status de integridade
CodeDeploy atribui dois valores de status de integridade a cada instância: *integridade da revisão e integridade da* *instância*.
Integridade da revisão
A integridade da revisão se baseia na revisão de aplicativo atualmente instalada na instância. Ela tem os seguintes valores de status:
+ Current: a revisão instalada na instância corresponde à revisão da última implantação bem-sucedida do grupo de implantação.
+ Old: a revisão instalada na instância corresponde a uma versão mais antiga do aplicativo.
+ Unknown: a revisão de aplicativo não foi instalada com sucesso na instância.
Integridade da instância
A integridade da instância se baseia em se as implementações em uma foram ou não bem-sucedidas. Ela tem os seguintes valores:
+ Healthy: a última implantação na instância foi bem-sucedida.
+ Unhealthy: a tentativa de implantar uma revisão na instância falhou, ou uma revisão ainda não foi implantada na instância.
CodeDeploy usa a integridade da revisão e a integridade da instância para agendar a implantação nas instâncias do grupo de implantação na seguinte ordem:
1. Integridade de instância - não íntegra.
1. Integridade da revisão - desconhecida.
1. Integridade da revisão - antiga.
1. Integridade da revisão - atual.
Se a implantação geral for bem-sucedida, a revisão será atualizada e os valores do status da integridade do grupo de implantação são atualizados para refletir a implantação mais recente.
+ Todas as instâncias atuais que tiveram uma implantação bem-sucedida permanecerão atuais. Caso contrário, elas se tornarão desconhecidas.
+ Todas as instâncias antigas ou desconhecidas que tiveram uma implantação bem-sucedida se tornarão atuais. Caso contrário, eles permanecerão antigas ou desconhecidas.
+ Todas as instâncias íntegras que tiveram uma implantação bem-sucedida permanecerão íntegras. Caso contrário, elas se tornarão não íntegras.
+ Todas as instâncias não íntegras que tiveram uma implantação bem-sucedida se tornarão íntegras. Caso contrário, eles permanecerão não íntegras.
Se a implantação geral falhar ou for interrompida:
+ Cada instância na qual CodeDeploy tentou implantar a revisão do aplicativo tem sua integridade definida como íntegra ou não íntegra, dependendo se a tentativa de implantação dessa instância foi bem-sucedida ou falhou.
+ Cada instância na qual CodeDeploy não tentou implantar a revisão do aplicativo mantém seu valor atual de integridade da instância.
+ A revisão do grupo de implantação permanecerá a mesma.
## Sobre o número mínimo de instâncias íntegras
O número mínimo necessário de instâncias íntegras é definido como parte de uma configuração de implantação.
**Importante**
Durante uma blue/green implantação, a configuração de implantação e o valor mínimo de hosts íntegros se aplicam às instâncias no ambiente substituto, não às do ambiente original. No entanto, quando as instâncias no ambiente original forem canceladas do balanceador de carga, a implantação geral será marcada como falha se o registro de até mesmo uma única instância original não for cancelado com sucesso.
CodeDeploy fornece três configurações de implantação padrão que normalmente usam valores mínimos de host íntegro:
| Nome da configuração de implantação padrão | Valor mínimo de hosts íntegros predefinido |
| --- | --- |
| CodeDeployDefault.OneAtATime | 1 |
| CodeDeployDefault.HalfAtATime | 50% |
| CodeDeployDefault.AllAtOnce | 0 |
Você encontrará mais informações sobre configurações de implantação padrão em [Trabalhando com configurações de implantação em CodeDeploy](deployment-configurations.md).
Você pode criar configurações de implantação personalizadas CodeDeploy para definir seus próprios valores mínimos de host íntegro. Você pode definir esses valores como números inteiros ou porcentagens usando as seguintes operações:
+ Como `minimum-healthy-hosts` quando você usa o [create-deployment-config](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-config.html)comando no AWS CLI.
+ Como `Value` no tipo de [MinimumHealthyHosts](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_MinimumHealthyHosts.html)dados na CodeDeploy API.
+ Como `MinimumHealthyHosts` quando você usa [AWS::CodeDeploy::DeploymentConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentconfig.html)em um CloudFormation modelo.
CodeDeploy permite que você especifique um número mínimo de instâncias íntegras para a implantação com duas finalidades principais:
+ Para determinar se a implantação geral foi bem-sucedida ou falhou. A implantação será bem-sucedida se a revisão de aplicativo tiver sido implantada com sucesso pelo menos no número mínimo de instâncias íntegras.
+ Para determinar o número de instâncias que devem ser íntegras durante uma implantação para permitir que essa implantação continue.
Você pode especificar o número mínimo de instâncias íntegras para o seu grupo de implantação como um número de instâncias ou como uma porcentagem do número total de instâncias. Se você especificar uma porcentagem, no início da implantação, CodeDeploy converterá a porcentagem no número equivalente de instâncias, arredondando todas as instâncias fracionárias.
CodeDeploy rastreia o status de integridade das instâncias do grupo de implantação durante o processo de implantação e usa o número mínimo especificado de instâncias íntegras da implantação para determinar se a implantação deve continuar. O princípio básico é que uma implantação nunca deve fazer com que o número de instâncias íntegras caia abaixo do número mínimo que você especificou. A única exceção a essa regra é quando um grupo de implantação tem inicialmente menos do que o número mínimo especificado de instâncias íntegras. Nesse caso, o processo de implantação não reduz ainda mais o número de instâncias íntegras.
**nota**
CodeDeploy tentará implantar em todas as instâncias em um grupo de implantação, mesmo aquelas que estão atualmente em um estado Parado. No cálculo do mínimo de hosts íntegros, uma instância interrompida tem o mesmo impacto que uma instância com falha. Para resolver falhas de implantação devido a muitas instâncias interrompidas, reinicie instâncias ou altere suas tags para excluí-las do grupo de implantação.
CodeDeploy inicia o processo de implantação tentando implantar a revisão do aplicativo nas instâncias não íntegras do grupo de implantação. Para cada implantação bem-sucedida, CodeDeploy altera o status de integridade da instância para íntegro e o adiciona às instâncias íntegras do grupo de implantação. CodeDeploy em seguida, compara o número atual de instâncias íntegras com o número mínimo especificado de instâncias íntegras.
+ Se o número de instâncias íntegras for menor ou igual ao número mínimo especificado de instâncias íntegras, CodeDeploy cancela a implantação para garantir que o número de instâncias íntegras não diminua com mais implantações.
+ Se o número de instâncias íntegras for maior que o número mínimo especificado de instâncias íntegras em pelo menos uma, CodeDeploy implanta a revisão do aplicativo no conjunto original de instâncias íntegras.
Se uma implantação em uma instância íntegra falhar, CodeDeploy alterará o status de integridade dessa instância para não íntegra. Conforme a implantação progride, CodeDeploy atualiza o número atual de instâncias íntegras e o compara com o número mínimo especificado de instâncias íntegras. Se o número de instâncias íntegras cair para o número mínimo especificado em qualquer ponto do processo de implantação, a implantação CodeDeploy será interrompida. Essa prática impede a possibilidade de falha da próxima implantação, diminuindo o número de instâncias íntegrasabaixo do mínimo especificado.
**nota**
Certifique-se de que o número mínimo de instâncias íntegras que você especificar seja menor que o número total de instâncias no grupo de implantação. Se você especificar um valor percentual, lembre-se de que ele será arredondado. Caso contrário, quando a implantação for iniciada, o número de instâncias íntegras já será menor que ou igual ao número mínimo especificado de instâncias íntegras, e o CodeDeploy reprovará imediatamente a implantação geral.
CodeDeploy também usa o número mínimo especificado de instâncias íntegras e o número real de instâncias íntegras para determinar se e como implantar a revisão do aplicativo em várias instâncias. Por padrão, CodeDeploy implanta a revisão do aplicativo no maior número possível de instâncias sem nenhum risco de que o número de instâncias íntegras fique abaixo do número mínimo especificado de instâncias íntegras.
Para determinar o número de instâncias que devem ser implantadas de uma só vez, CodeDeploy use o seguinte cálculo:
```
[total-hosts] - [minimum-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
Por exemplo:
+ Se seu grupo de implantação tiver 10 instâncias e você definir o número mínimo de instâncias íntegras como 9, CodeDeploy implanta em 1 instância por vez.
+ Se seu grupo de implantação tiver 10 instâncias e você definir o número mínimo de instâncias íntegras como 3, CodeDeploy implanta em 7 instâncias ao mesmo tempo no primeiro lote e depois nas 3 restantes no segundo lote.
+ Se seu grupo de implantação tiver 10 instâncias e você definir o número mínimo de instâncias íntegras como 0, CodeDeploy implanta em 10 instâncias ao mesmo tempo.
**Exemplos**
Os exemplos a seguir supõem um grupo de implantação com 10 instâncias.
Instâncias mínimas íntegras: 95%
CodeDeploy arredonda o número mínimo de instâncias íntegras para até 10 instâncias, o que equivale ao número de instâncias íntegras. A implantação global falhará imediatamente sem implantar a revisão em uma instância.
Instâncias mínimas íntegras: 9
CodeDeploy implanta a revisão em uma instância por vez. Se a implantação em qualquer uma das instâncias falhar, a implantação geral falhará CodeDeploy imediatamente, pois o número de instâncias íntegras é igual ao número mínimo de instâncias íntegras. A exceção a essa regra é que, se a última instância falhar, a implantação ainda será bem-sucedida.
CodeDeploy continua a implantação, uma instância por vez, até que qualquer implantação falhe ou a implantação geral seja concluída. Se todas as 10 implantações forem bem-sucedidas, o grupo de implantação tem 10 instâncias íntegras.
Instâncias mínimas íntegras: 8
CodeDeploy implanta a revisão em duas instâncias por vez. Se duas dessas implantações falharem, a implantação geral falhará CodeDeploy imediatamente. A exceção a essa regra é que, se a última instância for a segunda a falhar, a implantação ainda será bem-sucedida.
Instâncias mínimas íntegras: 0
CodeDeploy implanta a revisão em todo o grupo de implantação de uma só vez. A menos uma implantação a uma instância deve suceder para implantação total suceda. Se 0 instâncias estiverem íntegras, então a implantação falhará. Isso ocorre porque, para marcar uma implantação geral como bem-sucedida, no mínimo uma instância precisa estar íntegra quando a implantação geral for concluída, mesmo que o valor mínimo de instâncias íntegras seja 0.
## Sobre o número mínimo de instâncias íntegras por zona de disponibilidade.
**nota**
Esta seção utiliza os termos *instância* e *host* de forma intercambiável para se referir às instâncias do Amazon EC2.
Se você estiver implantando em instâncias em várias [zonas de disponibilidade](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones), você pode habilitar opcionalmente o [zonal configuration](deployment-configurations-create.md#zonal-config) recurso, que permite CodeDeploy implantar em uma zona de disponibilidade por vez.
Quando esse recurso estiver ativado, CodeDeploy garantirá que o número de hospedeiros saudáveis permaneça acima dos valores de “hospedeiros saudáveis mínimos por zona” *e* dos valores de “hospedeiros saudáveis mínimos”. Se o número de hosts íntegros ficar abaixo de qualquer um dos valores, a implantação CodeDeploy falhará em todas as zonas de disponibilidade.
Para calcular o número de hosts nos quais implantar de uma só vez, CodeDeploy use os valores de “hosts íntegros mínimos por zona” e “hosts íntegros mínimos”. CodeDeploy usará o *menor* dos cálculos `[A]` e`[B]`, onde `[A]` e onde `[B]` estão:
```
[A] = [total-hosts] - [min-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
```
[B] = [total-hosts-per-AZ] - [min-healthy-hosts-per-AZ] =
[number-of-hosts-to-deploy-to-at-once-per-AZ]
```
Depois de determinar o número de hosts nos quais implantar de uma vez, CodeDeploy implanta nos hosts em lotes desse número, uma zona de disponibilidade por vez, com uma pausa opcional (ou “tempo de cozimento”) entre as zonas.
**Exemplo**
Se a implantação estiver configurada como:
+ `[total-hosts]` é `200`
+ `[minimum-healthy-hosts]` é `160`
+ `[total-hosts-per-AZ]` é `100`
+ `[minimum-healthy-hosts-per-AZ]` é `50`
Então...
+ `[A]` = `200 - 160 = 40`
+ `[B]` = `100 - 50 = 50`
+ `40` é menor que `50`
Portanto, CodeDeploy será implantado nos `40` hosts de uma só vez.
Nesse cenário, a implantação ocorre da seguinte forma:
1. CodeDeploy é implantado na primeira zona de disponibilidade:
1. CodeDeploy é implantado nos primeiros `40` hosts.
1. CodeDeploy é implantado nos próximos `40` hosts.
1. CodeDeploy é implantado nos `20` hosts restantes.
A implantação na primeira zona de disponibilidade agora está concluída.
1. (Opcional) CodeDeploy aguarda enquanto a implantação na primeira zona “cozinha”, conforme definido pela configuração Duração do **monitor ou Adicionar uma duração** **do monitor para a primeira zona**. Se não houver problemas, CodeDeploy continua.
1. CodeDeploy implanta na segunda zona de disponibilidade:
1. CodeDeploy é implantado nos primeiros `40` hosts.
1. CodeDeploy é implantado nos próximos `40` hosts.
1. CodeDeploy é implantado nos `20` hosts restantes.
A implantação na segunda zona de disponibilidade final agora está concluída.
Para saber mais sobre o recurso de configuração de zonas e como especificar o número mínimo de instâncias íntegras por zona de disponibilidade, consulte [zonal configuration](deployment-configurations-create.md#zonal-config).