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á.
# Tutorial: Implante WordPress em uma instância do Amazon EC2 (Amazon Linux ou Red Hat Enterprise Linux e Linux, macOS ou Unix)
Neste tutorial, você implanta WordPress uma ferramenta de blog e um sistema de gerenciamento de conteúdo de código aberto baseados em PHP e MySQL em uma única instância do Amazon EC2 executando o Amazon Linux ou o Red Hat Enterprise Linux (RHEL).
Não é o que você está procurando?
+ Para praticar a implantação em uma instância do Amazon EC2 que executa o Windows Server, consulte [Tutorial: implantar um aplicativo "Hello, World\$1" aplicativo com CodeDeploy (Windows Server)](tutorials-windows.md).
+ Para praticar a implantação em uma instância on-premises, em vez de uma instância do Amazon EC2, 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).
As etapas deste tutorial são apresentadas sob a perspectiva de uma máquina de desenvolvimento local executando o Linux, macOS ou Unix. Embora possa concluir a maioria dessas etapas em uma máquina local executando o Windows, você precisa adaptar as etapas que fazem referência a comandos, como **chmod** e **wget**, a aplicativos, como o sed, e a caminhos de diretório, como `/tmp`.
Antes de começar este tutorial, você deve atender aos pré-requisitos em [Começando com CodeDeploy](getting-started-codedeploy.md). Isso inclui configurar um usuário, instalar ou atualizar o AWS CLI e criar um perfil de instância do IAM e uma função de serviço.
**Topics**
+ [Etapa 1: Iniciar e configurar uma instância Amazon Linux ou Red Hat Enterprise Linux Amazon EC2](tutorials-wordpress-launch-instance.md)
+ [Etapa 2: configurar seu conteúdo de origem para ser implantado na instância Amazon Linux ou Red Hat Enterprise Linux instância do Amazon EC2](tutorials-wordpress-configure-content.md)
+ [Etapa 3: Faça o upload do seu WordPress aplicativo para o Amazon S3](tutorials-wordpress-upload-application.md)
+ [Etapa 4: implantar seu WordPress aplicativo](tutorials-wordpress-deploy-application.md)
+ [Etapa 5: atualizar e reimplantar seu aplicativo WordPress](tutorials-wordpress-update-and-redeploy-application.md)
+ [Etapa 6: Limpe seu WordPress aplicativo e os recursos relacionados](tutorials-wordpress-clean-up.md)
# Etapa 1: Iniciar e configurar uma instância Amazon Linux ou Red Hat Enterprise Linux Amazon EC2
Para implantar o WordPress aplicativo CodeDeploy, você precisará de uma instância do Amazon EC2 executando o Amazon Linux ou o Red Hat Enterprise Linux (RHEL). A instância do Amazon EC2 requer uma nova regra de segurança de entrada que permita conexões HTTP. Essa regra é necessária para visualizar a WordPress página em um navegador após sua implantação bem-sucedida.
Siga as instruções em [Crie uma instância do Amazon EC2 para CodeDeploy](instances-ec2-create.md). Quando você chegar na parte dessas instruções sobre como atribuir uma tag de instância do Amazon EC2 à instância, certifique-se de especificar a chave da tag de **Name** e o valor da tag de **CodeDeployDemo**. (Se você especificar uma chave de tag ou um valor de tag diferente, as instruções em [Etapa 4: implantar seu WordPress aplicativo](tutorials-wordpress-deploy-application.md) poderão produzir resultados inesperados.)
Depois de seguir as instruções para iniciar a instância do Amazon EC2, retorne a essa página e continue na próxima seção. Não continue em [Crie um aplicativo com CodeDeploy](applications-create.md) como a próxima etapa.
## Conectar-se à instância do Amazon Linux ou RHEL Amazon EC2
Depois que a sua nova instância do Amazon EC2 for iniciada, siga essas instruções para praticar a conexão com ela.
1. Use o comando **ssh** (ou um emulador de terminal compatível com SSH, como o [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)) para conectar-se à instância do Amazon EC2 do Amazon Linux ou RHEL. Você precisará do endereço DNS público da instância e da chave privada para o par de chaves usado na inicialização da instância do Amazon EC2. Para obter mais informações, consulte [Conectar-se à sua instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html).
Por exemplo, se o endereço DNS público for **ec2-01-234-567-890.compute-1.amazonaws.com**, e o par de chaves da sua instância do Amazon EC2 para acesso SSH for denominado **codedeploydemo.pem**, você poderá digitar:
```
ssh -i /path/to/codedeploydemo.pem ec2-user@ec2-01-234-567-890.compute-1.amazonaws.com
```
Substitua `/path/to/codedeploydemo.pem` pelo caminho para o seu arquivo `.pem` e substitua o endereço DNS de exemplo pelo endereço de sua instância do Amazon EC2 do Amazon Linux ou RHEL.
**nota**
Se receber um erro de que as permissões do seu arquivo de chave são muito abertas, será necessário restringir suas permissões para dar acesso apenas ao usuário atual (você). Por exemplo, com o comando **chmod** no Linux, macOS ou Unix, digite:
```
chmod 400 /path/to/codedeploydemo.pem
```
1. Depois de entrar, você verá o banner da AMI da instância do Amazon EC2. Para o Amazon Linux, deve ficar assim:
```
__| __|_ )
_| ( / Amazon Linux AMI
___|\___|___|
```
1. Agora, você pode sair da instância do Amazon EC2 em execução.
**Atenção**
Não interrompa ou encerre a instância do Amazon EC2. Caso contrário, CodeDeploy não será possível implantá-lo.
## Adicione uma regra de entrada que permita tráfego HTTP à instância do Amazon EC2 do Amazon Linux ou do RHEL
A próxima etapa confirma que sua instância do Amazon EC2 tem uma porta HTTP aberta para que você possa ver a página inicial do aplicativo WordPress implantado em um navegador.
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. Escolha **Instâncias** e, em seguida, escolha sua instância.
1. Na guia **Descrição**, em **Grupos de segurança**, escolha **exibir regras de entrada**.
Você deve ver uma lista de regras em seu grupo de segurança como a seguinte:
```
Security Groups associated with i-1234567890abcdef0
Ports Protocol Source launch-wizard-N
22 tcp 0.0.0.0/0 ✔
```
1. Em **Grupos de segurança**, escolha o grupo de segurança para a sua instância do Amazon EC2. Ele pode se chamar **launch-wizard-*N***. O ***N*** no nome é um número atribuído ao grupo de segurança quando a instância foi criada.
Escolha a guia **Entrada**. Se o grupo de segurança da sua instância está configurado corretamente, você deve ver uma regra com os seguintes valores:
+ **Tipo:** HTTP
+ **Protocolo**: TCP
+ **Port Range**: 80
+ **Origem**: 0.0.0.0/0
1. Se você não encontrar uma regra com esses valores, use os procedimentos em [Adicionar regras a um grupo de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) para adicioná-las a uma nova regra de segurança.
# Etapa 2: configurar seu conteúdo de origem para ser implantado na instância Amazon Linux ou Red Hat Enterprise Linux instância do Amazon EC2
Agora é hora de configurar o conteúdo de origem do seu aplicativo, para que você tenha algo para implantar na instância.
**Topics**
+ [Obter o código-fonte](#tutorials-wordpress-configure-content-download-code)
+ [Criar scripts para executar seu aplicativo](#tutorials-wordpress-configure-content-create-scripts)
+ [Adicionar um arquivo de especificação de aplicativo](#tutorials-wordpress-configure-content-add-appspec-file)
## Obter o código-fonte
Neste tutorial, você implanta a plataforma de publicação de WordPress conteúdo da sua máquina de desenvolvimento na instância de destino do Amazon EC2. Para obter o WordPress código-fonte, você pode usar chamadas de linha de comando integradas. Ou, se tiver o Git instalado na sua máquina de desenvolvimento, poderá usá-lo como alternativa.
Para essas etapas, presumimos que você baixou uma cópia do WordPress código-fonte para o `/tmp` diretório em sua máquina de desenvolvimento. (É possível escolher qualquer diretório desejado, mas lembre-se de substituir `/tmp` pela localização sempre que esse diretório for especificado nas etapas.)
Escolha uma das duas opções a seguir para copiar os arquivos de WordPress origem para sua máquina de desenvolvimento. A primeira opção usa chamadas integradas de linha de comando. A segunda opção usa o Git.
**Topics**
+ [Para obter uma cópia do WordPress código-fonte (chamadas de linha de comando integradas)](#tutorials-wordpress-configure-content-download-code-command-line)
+ [Para obter uma cópia do WordPress código-fonte (Git)](#tutorials-wordpress-configure-content-download-code-git)
### Para obter uma cópia do WordPress código-fonte (chamadas de linha de comando integradas)
1. Chame o **wget** comando para baixar uma cópia do WordPress código-fonte, como um arquivo.zip, para o diretório atual:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
1. Chame os comandos **unzip**, **mkdir**, **cp** e **rm** para:
+ Descompactar o arquivo `master` .zip no `/tmp/WordPress_Temp` diretório (pasta).
+ Copiar seu conteúdo descompactado na pasta de destino `/tmp/WordPress`.
+ Excluir a pasta temporária `/tmp/WordPress_Temp` e o arquivo `master`.
Execute os comandos um de cada vez:
```
unzip master -d /tmp/WordPress_Temp
```
```
mkdir -p /tmp/WordPress
```
```
cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
```
```
rm -rf /tmp/WordPress_Temp
```
```
rm -f master
```
Isso deixa você com um conjunto limpo de arquivos de WordPress código-fonte na `/tmp/WordPress` pasta.
### Para obter uma cópia do WordPress código-fonte (Git)
1. Baixe e instale o [Git](http://git-scm.com) na sua máquina de desenvolvimento.
1. Na pasta `/tmp/WordPress`, chame o comando **git init**.
1. Chame o **git clone** comando para clonar o WordPress repositório público, fazendo sua própria cópia dele na pasta de `/tmp/WordPress` destino:
```
git clone https://github.com/WordPress/WordPress.git /tmp/WordPress
```
Isso deixa você com um conjunto limpo de arquivos de WordPress código-fonte na `/tmp/WordPress` pasta.
## Criar scripts para executar seu aplicativo
Em seguida, crie uma pasta e scripts no diretório. CodeDeploy usa esses scripts para configurar e implantar a revisão do seu aplicativo na instância de destino do Amazon EC2. É possível usar qualquer editor de texto para criar os scripts.
1. Crie um diretório de scripts em sua cópia do WordPress código-fonte:
```
mkdir -p /tmp/WordPress/scripts
```
1. Crie um arquivo `install_dependencies.sh` no `/tmp/WordPress/scripts`. Adicione as seguintes linhas ao arquivo. Este script `install_dependencies.sh` instala Apache, MySQL e PHP. Ele também adiciona suporte do MySQL ao PHP.
```
#!/bin/bash
sudo amazon-linux-extras install php7.4
sudo yum install -y httpd mariadb-server php
```
1. Crie um arquivo `start_server.sh` no `/tmp/WordPress/scripts`. Adicione as seguintes linhas ao arquivo. Este script `start_server.sh` inicia Apache e MySQL.
```
#!/bin/bash
systemctl start mariadb.service
systemctl start httpd.service
systemctl start php-fpm.service
```
1. Crie um arquivo `stop_server.sh` no `/tmp/WordPress/scripts`. Adicione as seguintes linhas ao arquivo. Este script `stop_server.sh` para Apache e MySQL.
```
#!/bin/bash
isExistApp="pgrep httpd"
if [[ -n $isExistApp ]]; then
systemctl stop httpd.service
fi
isExistApp=pgrep mysqld
if [[ -n $isExistApp ]]; then
systemctl stop mariadb.service
fi
isExistApp=pgrep php-fpm
if [[ -n $isExistApp ]]; then
systemctl stop php-fpm.service
fi
```
1. Crie um arquivo `create_test_db.sh` no `/tmp/WordPress/scripts`. Adicione as seguintes linhas ao arquivo. Esse `create_test_db.sh` script usa o MySQL para criar um **test** banco de dados WordPress para uso.
```
#!/bin/bash
mysql -uroot <
Em seguida, adicione um arquivo de especificação do aplicativo (AppSpec arquivo), um arquivo formatado em [YAML](http://www.yaml.org) usado por to: CodeDeploy
+ Mapear os arquivos de origem na sua revisão de aplicativo para os respectivos destinos na instância do Amazon EC2 de destino.
+ Especificar permissões personalizadas para arquivos implantados.
+ Especificar os scripts a serem executados na instância do Amazon EC2 de destino durante a implantação.
O AppSpec arquivo deve ser nomeado`appspec.yml`. Ele deve ser colocado no diretório raiz do código-fonte do aplicativo. Neste tutorial, o diretório raiz é `/tmp/WordPress`.
Com seu editor de texto, crie um arquivo chamado `appspec.yml`. Adicione as seguintes linhas ao arquivo:
```
version: 0.0
os: linux
files:
- source: /
destination: /var/www/html/WordPress
hooks:
BeforeInstall:
- location: scripts/install_dependencies.sh
timeout: 300
runas: root
AfterInstall:
- location: scripts/change_permissions.sh
timeout: 300
runas: root
ApplicationStart:
- location: scripts/start_server.sh
- location: scripts/create_test_db.sh
timeout: 300
runas: root
ApplicationStop:
- location: scripts/stop_server.sh
timeout: 300
runas: root
```
CodeDeploy usa esse AppSpec arquivo para copiar todos os arquivos da `/tmp/WordPress` pasta na máquina de desenvolvimento para a `/var/www/html/WordPress` pasta na instância do Amazon EC2 de destino. Durante a implantação, CodeDeploy executa os scripts especificados como `root` na `/var/www/html/WordPress/scripts` pasta na instância de destino do Amazon EC2 em eventos específicos durante o ciclo de vida da implantação, como e. **BeforeInstall** **AfterInstall** Se algum desses scripts levar mais de 300 segundos (5 minutos) para ser executado, CodeDeploy interrompe a implantação e marca a implantação como falhada.
Para obter mais informações sobre essas configurações, consulte o [CodeDeploy AppSpec referência de arquivo](reference-appspec-file.md).
**Importante**
Os locais e números de espaços entre cada um dos itens desse arquivo são importantes. Se o espaçamento estiver incorreto, CodeDeploy gera um erro que pode ser difícil de depurar. Para obter mais informações, consulte [AppSpec Espaçamento de arquivos](reference-appspec-file.md#reference-appspec-file-spacing).
# Etapa 3: Faça o upload do seu WordPress aplicativo para o Amazon S3
Agora você preparará e enviará seu conteúdo de origem para um local a partir do qual CodeDeploy possa implantá-lo. As instruções a seguir mostram como provisionar um bucket do Amazon S3, preparar os arquivos da revisão de aplicativo para o bucket, agrupar os arquivos da revisão e, em seguida, enviá-la para esse bucket.
**nota**
Embora não seja abordado neste tutorial, você pode usá-lo CodeDeploy para implantar aplicativos de GitHub repositórios para instâncias. Para obter mais informações, consulte [Integrando com CodeDeploy GitHub](integrations-partners-github.md).
**Topics**
+ [Provisionar um bucket do Amazon S3](#tutorials-wordpress-upload-application-create-s3-bucket)
+ [Preparar os arquivos do aplicativo para o bucket](#tutorials-wordpress-upload-application-prepare-application-files)
+ [Agrupar os arquivos do aplicativo em um único arquivamento e enviar o arquivamento](#tutorials-wordpress-upload-application-bundle-and-push-archive)
## Provisionar um bucket do Amazon S3
Crie um contêiner de armazenamento, ou *bucket*, no Amazon S3, ou use um bucket existente. Certifique-se de que você possa carregar a revisão no bucket e de que as instâncias do Amazon EC2 usadas nas implantações possam baixá-la desse bucket.
Você pode usar o AWS CLI console do Amazon S3 ou o Amazon S3 para criar um bucket do Amazon APIs S3. Depois de criar o bucket, certifique-se de dar permissões de acesso a ele e à sua conta do AWS .
**nota**
Os nomes dos buckets devem ser exclusivos no Amazon S3 para todas as contas AWS . Se não for possível usar **amzn-s3-demo-bucket**, tente um nome de bucket diferente, como **amzn-s3-demo-bucket**, seguido por um traço e suas iniciais ou algum outro identificador exclusivo. Em seguida, certifique-se de substituir o nome do bucket por **amzn-s3-demo-bucket** sempre que essa identificação aparecer neste tutorial.
O bucket do Amazon S3 deve ser criado na mesma AWS região em que suas instâncias de destino do Amazon EC2 são lançadas. Por exemplo, se você criar o bucket na região Leste dos EUA (Norte da Virgínia), suas instâncias do Amazon EC2 de destino devem ser lançadas na região Leste dos EUA (Norte da Virgínia).
**Topics**
+ [Como criar um bucket do Amazon S3 (CLI)](#tutorials-wordpress-upload-application-create-s3-bucket-cli)
+ [Como criar um bucket do Amazon S3 (console)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Conceda permissões ao bucket e à conta do Amazon S3 AWS](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)
### Como criar um bucket do Amazon S3 (CLI)
Chame o comando **mb** para criar um bucket do Amazon S3 denominado **amzn-s3-demo-bucket**:
```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```
### Como criar um bucket do Amazon S3 (console)
1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No console do Amazon S3, escolha **Criar bucket**.
1. Na caixa **Nome do bucket**, digite um nome para o bucket.
1. Na lista **Região**, escolha a região de destino e escolha **Criar**.
### Conceda permissões ao bucket e à conta do Amazon S3 AWS
Você deve ter permissões para fazer upload no bucket do Amazon S3. Você pode especificar essas permissões por meio de uma política de bucket do Amazon S3. Por exemplo, na seguinte política de bucket do Amazon S3, o uso do caractere curinga (\$1) permite que `111122223333` a AWS conta faça upload de arquivos para qualquer diretório no bucket do Amazon S3 chamado: `amzn-s3-demo-bucket`
```
{
"Statement": [
{
"Action": [
"s3:PutObject"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"111122223333"
]
}
}
]
}
```
Para ver o ID AWS da sua conta, consulte [Encontrando o ID AWS da sua conta](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).
Agora é um bom momento para verificar se o bucket do Amazon S3 permitirá solicitações de download de cada instância participante do Amazon EC2. É possível especificar isso por meio de uma política do bucket do Amazon S3. Por exemplo, na seguinte política de bucket do Amazon S3, usar o caractere curinga (\$1) permite que qualquer instância do Amazon EC2 com um perfil de instância anexado do IAM contendo o ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` faça o download de arquivos de qualquer diretório no bucket do Amazon S3 chamado de `amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/CodeDeployDemo"
]
}
}
]
}
```
Para obter informações sobre como gerar e anexar uma política de bucket do Amazon S3, consulte [Exemplos de políticas de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).
Para obter informações sobre como criar e anexar uma política do IAM, consulte [Trabalhando com políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console).
## Preparar os arquivos do aplicativo para o bucket
Certifique-se de que os arquivos do WordPress aplicativo, o AppSpec arquivo e os scripts estejam organizados em sua máquina de desenvolvimento de forma semelhante à seguinte:
```
/tmp/
|--WordPress/
|-- appspec.yml
|-- scripts/
| |-- change_permissions.sh
| |-- create_test_db.sh
| |-- install_dependencies.sh
| |-- start_server.sh
| |-- stop_server.sh
|-- wp-admin/
| |-- (various files...)
|-- wp-content/
| |-- (various files...)
|-- wp-includes/
| |-- (various files...)
|-- index.php
|-- license.txt
|-- readme.html
|-- (various files ending with .php...)
```
## Agrupar os arquivos do aplicativo em um único arquivamento e enviar o arquivamento
Agrupe os arquivos do WordPress aplicativo e o AppSpec arquivo em um arquivo compactado (conhecido como *revisão* do aplicativo).
**nota**
Você pode ser cobrado por armazenar objetos em um bucket e por transferir revisões de aplicativos para dentro e fora de um bucket. Para obter mais informações, consulte [Preço do Amazon S3](https://aws.amazon.com/s3/pricing/).
1. Na máquina de desenvolvimento, mude para a pasta na qual os arquivos estão armazenados:
```
cd /tmp/WordPress
```
**nota**
Se você não mudar para essa pasta, o empacotamento de arquivos começará na sua pasta atual. Por exemplo, se a sua pasta atual for `/tmp` em vez de `/tmp/WordPress`, o empacotamento começará com arquivos e subpastas na pasta `tmp`, o que pode incluir mais do que a subpasta `WordPress`.
1. Chame o comando **create-application** para registrar um novo aplicativo denominado **WordPress\$1App**:
```
aws deploy create-application --application-name WordPress_App
```
1. Chame o comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) para agrupar os arquivos, fazer o upload das revisões para o Amazon S3 e registrar informações sobre a revisão CodeDeploy carregada, tudo em uma única ação.
```
aws deploy push \
--application-name WordPress_App \
--s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
--ignore-hidden-files
```
Esse comando agrupa os arquivos do diretório atual (excluindo os arquivos ocultos) em um único arquivo chamado**WordPressApp.zip**, carrega a revisão no **amzn-s3-demo-bucket** bucket e registra as informações CodeDeploy sobre a revisão carregada.
# Etapa 4: implantar seu WordPress aplicativo
Agora você implanta o exemplo de revisão do WordPress aplicativo que você carregou no Amazon S3. Você pode usar o console AWS CLI ou o CodeDeploy console para implantar a revisão e monitorar o progresso da implantação. Depois que a revisão do aplicativo for implementada com êxito, confira os resultados.
**Topics**
+ [Implante a revisão do seu aplicativo com CodeDeploy](#tutorials-wordpress-deploy-application-create-deployment)
+ [Monitorar sua implantação e solucionar problemas relacionados](#tutorials-wordpress-deploy-application-monitor)
+ [Verificar sua implantação](#tutorials-wordpress-deploy-application-verify-deployment)
## Implante a revisão do seu aplicativo com CodeDeploy
Use o console AWS CLI ou o console para implantar a revisão do seu aplicativo.
**Topics**
+ [Para implantar sua revisão de aplicativo (CLI)](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Para implantar sua revisão de aplicativo (console)](#tutorials-wordpress-deploy-application-create-deployment-console)
### Para implantar sua revisão de aplicativo (CLI)
1. A implantação precisa de um grupo de implantação. No entanto, antes de criar o grupo de implantação, você precisa de um ARN de um perfil de serviço. Um perfil de serviço é um perfil do IAM que dá a um serviço permissão para agir em seu nome. Nesse caso, a função de serviço dá CodeDeploy permissão para acessar suas instâncias do Amazon EC2 para expandir (ler) suas tags de instância do Amazon EC2.
Você já deve ter seguido as instruções em [Criar um perfil de serviço (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) para criar um perfil de serviço. Para obter o ARN do perfil de serviço, consulte [Obter o ARN do perfil de serviço (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Agora que você tem o ARN do perfil de serviço, chame o comando **create-deployment-group** para criar um grupo de implantação chamado **WordPress\$1DepGroup**, associado ao aplicativo chamado **WordPress\$1App**, usando a tag do Amazon EC2 chamada **CodeDeployDemo** e a configuração de implantação chamada **CodeDeployDefault.OneAtATime**:
```
aws deploy create-deployment-group \
--application-name WordPress_App \
--deployment-group-name WordPress_DepGroup \
--deployment-config-name CodeDeployDefault.OneAtATime \
--ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE \
--service-role-arn serviceRoleARN
```
**nota**
O [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando fornece suporte para a criação de acionadores que resultam no envio de notificações do Amazon SNS aos assinantes do tópico sobre eventos específicos em implantações e instâncias. O comando também oferece suporte a opções para reverter automaticamente as implantações e configurar alarmes para interromper as implantações quando os limites de monitoramento nos alarmes da CloudWatch Amazon forem atingidos. Os comandos para essas ações não estão incluídos neste tutorial.
1. Antes de criar uma implantação, as instâncias do seu grupo de implantação devem ter o CodeDeploy agente instalado. Você pode instalar o agente a partir da linha de comando do AWS Systems Manager , com o seguinte comando:
```
aws ssm create-association \
--name AWS-ConfigureAWSPackage \
--targets Key=tag:Name,Values=CodeDeployDemo \
--parameters action=Install,name=AWSCodeDeployAgent \
--schedule-expression "cron(0 2 ? * SUN *)"
```
Esse comando cria uma associação no Systems Manager State Manager que instalará o CodeDeploy agente e tentará atualizá-lo às 2:00 de cada manhã de domingo. Para obter mais informações sobre o CodeDeploy agente, consulte [Trabalhando com o CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Para obter mais informações sobre o Systems Manager, consulte [O que é o AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
1. Agora, chame o comando **create-deployment** para criar uma implantação associada ao aplicativo **WordPress\$1App**, a configuração de implantação **CodeDeployDefault.OneAtATime** e o grupo de implantação **WordPress\$1DepGroup**, usando a revisão de aplicativo **WordPressApp.zip** no bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
### Para implantar sua revisão de aplicativo (console)
1. Antes de usar o CodeDeploy console para implantar a revisão do aplicativo, você precisa de um ARN de função de serviço. Um perfil de serviço é um perfil do IAM que dá a um serviço permissão para agir em seu nome. Nesse caso, a função de serviço dá CodeDeploy permissão para acessar suas instâncias do Amazon EC2 para expandir (ler) suas tags de instância do Amazon EC2.
Você já deve ter seguido as instruções em [Criar um perfil de serviço (console)](getting-started-create-service-role.md#getting-started-create-service-role-console) para criar um perfil de serviço. Para obter o ARN do perfil de serviço, consulte [Obter o ARN do perfil de serviço (console)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Agora que você tem o ARN, use o CodeDeploy console para implantar a revisão do seu aplicativo:
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 a opção **Implantar** e escolha **Aplicações**.
1. Na lista de aplicativos, escolha **WordPress\$1App**.
1. Na guia **Grupos de implantação**, selecione **Criar um grupo de implantação**.
1. Em **Nome do grupo de implantação**, insira **WordPress\$1DepGroup**.
1. Em **Deployment type**, escolha **In-place deployment**.
1. Em **Configuração do ambiente**, selecione **Instâncias do Amazon EC2**.
1. Em **Configuração do agente com AWS Systems Manager**, mantenha os padrões.
1. Em **Chave**, insira **Name**.
1. Em **Valor**, informe **CodeDeployDemo**.
**nota**
Depois de digitar**CodeDeployDemo**, um **1** deve aparecer em **Matching instances** para confirmar que CodeDeploy encontrou uma instância correspondente do Amazon EC2.
1. Em **Configuração de implantação**, escolha **CodeDeployDefault. OneAtATime**.
1. Em **Service role ARN (ARN da função de serviço)**, selecione o ARN da função de serviço e, em seguida, escolha **Create deployment group (Criar grupo de implantação)**.
1. Escolha **Criar implantação**.
1. Em **Deployment group (Grupo de implantação)**, selecione **WordPress\$1DepGroup**.
1. Ao lado de **Tipo de repositório**, selecione **Meu aplicativo está armazenado no Amazon S3**. Em **Local da revisão**, insira o local do exemplo de revisão do WordPress aplicativo que você enviou anteriormente para o Amazon S3. Para obter a localização:
1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Na lista de buckets, selecione **amzn-s3-demo-bucket** (ou o nome do bucket no qual você fez upload da sua revisão de aplicação).
1. Na lista de objetos, escolha **WordPressApp.zip.**
1. Na guia **Visão geral**, copie o valor do campo **Link** na área de transferência.
A aparência pode ser semelhante a esta:
**https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**
1. Retorne ao CodeDeploy console e, em **Local da revisão**, cole o valor do campo **Link**.
1. Se uma mensagem aparecer na lista **File type** (Tipo de arquivo), indicando que o tipo de arquivo não pôde ser detectado, escolha **.zip**.
1. (Opcional) Digite um comentário na caixa **Deployment description**.
1. **Expanda **Substituições de grupos de implantação** e, em **Configuração de implantação, escolha**. CodeDeployDefault OneAtATime**.
1. Selecione **Iniciar implantação**. As informações sobre a implantação recém-criada aparecem na página **Implantações**.
## Monitorar sua implantação e solucionar problemas relacionados
Use o console AWS CLI ou o console para monitorar e solucionar problemas de sua implantação.
**Topics**
+ [Para monitorar e solucionar problemas de implantação (CLI)](#tutorials-wordpress-deploy-application-monitor-cli)
+ [Para monitorar e solucionar problemas de implantação (console)](#tutorials-wordpress-deploy-application-monitor-console)
### Para monitorar e solucionar problemas de implantação (CLI)
1. Obtenha o ID de implantação chamando o comando **list-deployments** para o aplicativo chamado **WordPress\$1App** e o grupo de implantação chamado **WordPress\$1DepGroup**:
```
aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_DepGroup --query 'deployments' --output text
```
1. Chame o comando **get-deployment** com o ID da implantação:
```
aws deploy get-deployment --deployment-id deploymentID --query 'deploymentInfo.status' --output text
```
1. O comando retorna o status geral da implantação. Se a implantação for bem-sucedida, o valor será `Succeeded`.
Se o status geral for `Failed`, você poderá chamar comandos como [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) e [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) para solucionar problemas. Para mais opções de solução de problemas, consulte [Analisando arquivos de log para investigar falhas de implantação em instâncias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
### Para monitorar e solucionar problemas de implantação (console)
Na página **Implantações** no CodeDeploy console, você pode monitorar o status da sua implantação na coluna **Status**.
Para obter mais informações sobre a implantação, especialmente se o valor da coluna **Status** tiver qualquer outro valor que não **Succeeded**:
1. Na tabela **Deployments (Implantações)**, selecione o nome da implantação. Depois que uma implantação falhar, uma mensagem descrevendo o motivo da falha será exibida.
1. Na **Instance activity (Atividade da instância)**, mais informações sobre a implantação são exibidas. Depois que uma implantação apresentar falha, você possivelmente conseguirá determinar em quais instâncias do Amazon EC2 e em qual etapa ocorreu a falha.
1. Se quiser realizar outros procedimentos de solução de problemas, use uma técnica como a descrita em [Visualizar detalhes da instância com o CodeDeploy](instances-view-details.md). Você também pode analisar os arquivos de log de implantação em uma instância do Amazon EC2. Para obter mais informações, consulte [Analisando arquivos de log para investigar falhas de implantação em instâncias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
## Verificar sua implantação
Depois que sua implantação for bem-sucedida, verifique se WordPress a instalação está funcionando. Use o endereço DNS público da instância do Amazon EC2, seguido por `/WordPress`, para visualizar seu site em um navegador da Web. (Para obter o valor DNS público, no console do Amazon EC2, escolha a instância do Amazon EC2 e, na guia **Descrição**, procure o valor de **DNS público**.)
Por exemplo, se o endereço DNS público da sua instância do Amazon EC2 for **ec2-01-234-567-890.compute-1.amazonaws.com**, você usará o seguinte URL:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress
```
Ao visualizar o site em seu navegador, você deve ver uma página de WordPress boas-vindas semelhante à seguinte:
![\[WordPress página de boas-vindas\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)
Se sua instância do Amazon EC2 não tiver uma regra de entrada HTTP adicionada ao seu grupo de segurança, a página de WordPress boas-vindas não aparecerá. Se aparecer uma mensagem indicando que o servidor remoto não está respondendo, certifique-se de que o grupo de segurança de sua instância do Amazon EC2 tenha a regra de entrada. Para obter mais informações, consulte [Adicione uma regra de entrada que permita tráfego HTTP à instância do Amazon EC2 do Amazon Linux ou do RHELAdicionar uma regra de entrada que permita tráfego HTTP à instância do Amazon EC2 do Windows Server.](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule).
# Etapa 5: atualizar e reimplantar seu aplicativo WordPress
Agora que você implantou com sucesso a revisão do aplicativo, atualize o WordPress código na máquina de desenvolvimento e use-o CodeDeploy para reimplantar o site. Em seguida, você deve ver as alterações de código na instância do Amazon EC2.
**Topics**
+ [Configurar o WordPress site](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Modificar o site](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Reimplantar o site](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)
## Configurar o WordPress site
Para ver os efeitos da alteração do código, conclua a configuração do WordPress site para que você tenha uma instalação totalmente funcional.
1. Digite a URL do seu site no navegador. A URL é o endereço DNS público da instância do Amazon EC2 mais a extensão `/WordPress`. Para este WordPress site de exemplo (e exemplo de endereço DNS público da instância Amazon EC2), a URL é. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**
1. Se você ainda não configurou o site, a página de boas-vindas WordPress padrão é exibida. Escolha **Let's go\$1**.
1. Na página de configuração do banco de dados, digite os seguintes valores para usar o banco de dados MySQL padrão:
+ **Nome do banco de dados**: **test**
+ **Nome de usuário**: **root**
+ **Senha**: deixe em branco.
+ **Host do banco de dados**: **localhost**
+ **Prefixo da tabela**: **wp\$1**
Escolha **Submit** para configurar o banco de dados.
1. Continue a configuração do site. Na página de **boas-vindas**, preencha os valores desejados e escolha **Instalar WordPress**. Quando a instalação estiver concluída, faça login no seu painel.
**Importante**
Durante a implantação do WordPress aplicativo, o **change\$1permissions.sh** script atualizou as permissões da `/tmp/WordPress` pasta para que qualquer pessoa possa gravar nela. Agora é um bom momento para executar o comando a seguir e restringir permissões para que apenas você, o proprietário, possa gravar nele:
```
chmod -R 755 /var/www/html/WordPress
```
## Modificar o site
Para modificar o WordPress site, acesse a pasta do aplicativo em sua máquina de desenvolvimento:
```
cd /tmp/WordPress
```
Para modificar algumas das cores do site, no arquivo `wp-content/themes/twentyfifteen/style.css`, use um editor de texto ou **sed** para alterar `#fff` para `#768331`.
No Linux ou outros sistemas com o GNU **sed**, use:
```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
No macOS, Unix ou outros sistemas com o BSD **sed**, use:
```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
## Reimplantar o site
Agora que você modificou o código do site, use o Amazon S3 CodeDeploy para reimplantar o site.
Agrupe e carregue as alterações no Amazon S3, conforme descrito em [Agrupar os arquivos do aplicativo em um único arquivamento e enviar o arquivamento](tutorials-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive). (Ao seguir essas instruções, lembre-se de que não é necessário criar um aplicativo.) Especifique a mesma chave de antes para a nova revisão (**WordPressApp.zip**). Faça upload dela no mesmo bucket do Amazon S3 criado anteriormente (por exemplo, **amzn-s3-demo-bucket**).
Use o AWS CLI, o CodeDeploy console ou o CodeDeploy APIs para reimplantar o site.
**Topics**
+ [Para redistribuir o site (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Para reimplantar o site (console)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)
### Para redistribuir o site (CLI)
Chame o comando **create-deployment** para criar uma implantação com base na revisão recém-carregada. Use o aplicativo **WordPress\$1App**, a configuração de implantação **CodeDeployDefault.OneAtATime**, o grupo de implantação **WordPress\$1DepGroup**, e a revisão **WordPressApp.zip** no bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
Você pode verificar o status da implantação conforme descrito em [Monitorar sua implantação e solucionar problemas relacionados](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Depois CodeDeploy de reimplantar o site, visite novamente o site em seu navegador para verificar se as cores foram alteradas. (Talvez seja necessário atualizar o navegador.) Se as cores mudaram, parabéns\$1 Você modificou e reimplantou seu site com sucesso\$1
### Para reimplantar o site (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 a opção **Implantar** e escolha **Aplicações**.
1. Na lista de aplicativos, escolha **WordPress\$1App**.
1. Na guia **Grupos de implantação**, escolha **WordPress\$1DepGroup**.
1. Escolha **Criar implantação**.
1. Na página **Create deployment**:
1. Em **Deployment group (Grupo de implantação)**, selecione **WordPress\$1DepGroup**.
1. Na área **Tipo de repositório**, selecione **Meu aplicativo está armazenado no Amazon S3** e copie o link do Amazon S3 da revisão para a caixa **Local de revisão**. Para encontrar o valor do link:
1. Em uma guia separada do navegador:
Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
Navegue até **amzn-s3-demo-bucket**, abra-o e, depois, selecione sua revisão: **WordPressApp.zip**.
1. Se o painel **Propriedades** não estiver visível no console do Amazon S3, escolha o botão **Propriedades**.
1. No painel **Propriedades**, copie o valor do campo **Link** na caixa **Local da revisão** no CodeDeploy console.
1. Se uma mensagem aparecer informando que o tipo de arquivo não pôde ser detectado, escolha **.zip**.
1. Deixe a caixa **Descrição da implantação** em branco.
1. **Expanda as **substituições do grupo de implantação** e, em **Configuração de implantação, escolha**. CodeDeployDefault OneAtATime**.
1. Selecione **Iniciar implantação**. As informações sobre a implantação recém-criada aparecem na página **Implantações**.
1. Você pode verificar o status da implantação conforme descrito em [Monitorar sua implantação e solucionar problemas relacionados](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Depois CodeDeploy de reimplantar o site, visite novamente o site em seu navegador para verificar se as cores foram alteradas. (Talvez seja necessário atualizar o navegador.) Se as cores mudaram, parabéns\$1 Você modificou e reimplantou seu site com sucesso\$1
# Etapa 6: Limpe seu WordPress aplicativo e os recursos relacionados
Agora você atualizou o WordPress código com sucesso e reimplantou o site. Para evitar cobranças contínuas pelos recursos criados para este tutorial, você deve excluir o seguinte:
+ Qualquer CloudFormation pilha (ou encerre qualquer instância do Amazon EC2, se você as criou fora do). CloudFormation
+ Qualquer bucket do Amazon S3.
+ O aplicativo `WordPress_App` no CodeDeploy.
+ A associação AWS Systems Manager do gerente estadual para o CodeDeploy agente.
Você pode usar o AWS CLI, o CloudFormation, o Amazon S3, o Amazon EC2 CodeDeploy e os consoles, ou AWS APIs o para realizar a limpeza.
**Topics**
+ [Para limpar recursos (CLI)](#tutorials-wordpress-clean-up-cli)
+ [Para limpar recursos (console)](#tutorials-wordpress-clean-up-console)
+ [Próximas etapas](#tutorials-wordpress-clean-up-whats-next)
## Para limpar recursos (CLI)
1. Se você usou nosso CloudFormation modelo para este tutorial, chame o **delete-stack** comando na pilha chamada**CodeDeployDemoStack**. Isso encerrará todas as instâncias do Amazon EC2 acompanhantes e excluirá todos os perfis do IAM acompanhantes que essa pilha criou:
```
aws cloudformation delete-stack --stack-name CodeDeployDemoStack
```
1. Para excluir o bucket do Amazon S3, chame o comando **rm** com a opção **--recursive** para o bucket denominado **amzn-s3-demo-bucket**. Isso excluirá o bucket e todos os seus objetos:
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Para excluir o aplicativo `WordPress_App`, chame o comando **delete-application**. Isso também excluirá todos os registros do grupo de implantação associados e os registros de implantação do aplicativo:
```
aws deploy delete-application --application-name WordPress_App
```
1. Para excluir a associação do gerenciador de estados do Systems Manager, chame o comando **delete-association**.
```
aws ssm delete-association --assocation-id association-id
```
Você pode obter o *association-id* chamando o **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
Se você não usou a CloudFormation pilha para este tutorial, chame o **terminate-instances** comando para encerrar todas as instâncias do Amazon EC2 que você criou manualmente. Forneça o ID da instância do Amazon EC2 a ser encerrada:
```
aws ec2 terminate-instances --instance-ids instanceId
```
## Para limpar recursos (console)
Se você usou nosso CloudFormation modelo para este tutorial, exclua a CloudFormation pilha associada.
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/).
1. Na caixa **Filtro**, digite o nome da CloudFormation pilha que você criou anteriormente (por exemplo,**CodeDeployDemoStack**).
1. Marque a caixa ao lado do nome da pilha. No menu **Ações**, escolha **Excluir pilha**.
CloudFormation exclui a pilha, encerra todas as instâncias acompanhantes do Amazon EC2 e exclui todas as funções do IAM associadas.
Para encerrar instâncias do Amazon EC2 que você criou fora de CloudFormation uma pilha:
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. Na lista **INSTÂNCIAS**, escolha **Instâncias**.
1. Na caixa de pesquisa, digite o nome da instância do Amazon EC2 que você deseja encerrar (por exemplo, **CodeDeployDemo**) e depois pressione Enter.
1. Escolha o nome da instância do Amazon EC2
1. No menu **Ações**, selecione **Estado da instância** e escolha **Encerrar**. Quando solicitado, escolha **Sim, Encerrar**.
Repita essas etapas para cada instância.
Para excluir o bucket do Amazon S3:
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Na lista de buckets, navegue e escolha o nome do bucket do Amazon S3 que você criou anteriormente (por exemplo, **amzn-s3-demo-bucket**).
1. Antes de poder excluir um bucket, você deve excluir seu conteúdo. Selecione todos os arquivos no bucket, como **WordPressApp.zip**. No menu **Ações**, escolha **Excluir**. Quando solicitado a confirmar a exclusão, escolha **OK**.
1. Depois que o bucket estiver vazio, você poderá excluí-lo. Na lista de buckets, escolha a linha do bucket (mas não o nome do bucket). Escolha **Excluir bucket** e quando solicitado a confirmar, escolha **OK**.
Para excluir o `WordPress_App` aplicativo de CodeDeploy:
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 a opção **Implantar** e escolha **Aplicações**.
1. Na lista de aplicativos, escolha **WordPress\$1App**.
1. Na página **Detalhes da aplicação**, escolha **Excluir aplicativo**.
1. Quando solicitado, digite o nome do aplicativo para confirmar que você deseja excluí-lo e, em seguida, escolha **Excluir**.
Para excluir a associação do gerenciador de estados do Systems Manager:
1. Abra o AWS Systems Manager console em https://console.aws.amazon.com /systems-manager.
1. No painel de navegação, escolha **State Manager**.
1. Escolha a associação criada e selecione **Excluir**.
## Próximas etapas
Se você chegou até aqui, parabéns\$1 Você concluiu com êxito uma implantação do CodeDeploy e, depois, atualizou o código do seu site e o reimplantou.