Criando um RFC usando a CLI Crie um pacote WordPress de aplicativos para CodeDeploy Implante o pacote de WordPress aplicativos com CodeDeploy Validar a implantação do aplicativo Acabe com a implantação de aplicativos

Tutorial de CLI: Implantação de um site Tier and Tie WordPress

Esta seção descreve como implantar um WordPress site de alta disponibilidade (HA) em um ambiente AMS usando a CLI do AMS. Esse conjunto de instruções inclui um exemplo de criação do arquivo de pacote WordPress CodeDeploy compatível necessário (por exemplo, zip).

nota

Este passo a passo de implantação foi projetado para uso com um ambiente Linux AMZN.

Os parâmetros essenciais da variável são anotados comoreplaceable; no entanto, talvez você queira modificar outros parâmetros para se adequar à sua situação.

Resumo das tarefas e tarefas necessárias RFCs:

Crie a infraestrutura:
1. Crie uma pilha RDS (CLI)
2. Criar um balanceador de carga
3. Crie um grupo de Auto Scaling e vincule-o ao balanceador de carga
4. Crie um bucket S3 para aplicativos CodeDeploy
Crie um pacote de WordPress aplicativos (não requer um RFC)
Implante o pacote de WordPress aplicativos com CodeDeploy:
1. Crie um CodeDeploy aplicativo
2. Crie um grupo CodeDeploy de implantação
3. Carregue seu pacote de WordPress aplicativos no bucket do S3 (não requer um RFC)
4. Implemente o CodeDeploy aplicativo
Valide a implantação
Destrua a implantação

Siga todas as etapas na linha de comando da sua conta autenticada.

Criando um RFC usando a CLI

Para obter informações detalhadas sobre a criação RFCs, consulte Criação RFCs; para obter uma explicação dos parâmetros comuns de RFC, consulte Parâmetros comuns de RFC.

Crie um pacote WordPress de aplicativos para CodeDeploy

Esta seção fornece um exemplo de criação de um pacote de implantação de aplicativos.

Baixe WordPress, extraia os arquivos e crie um. diretório /scripts.

Comando Linux:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
Windows: cole https://github.com/WordPress/WordPress/archive/master.zip em uma janela do navegador e baixe o arquivo zip.

Crie um diretório temporário no qual montar o pacote.

Linux
```
mkdir /tmp/WordPress
```
Windows: Crie um diretório WordPress "", você usará o caminho do diretório posteriormente.
Extraia a WordPress fonte para o diretório WordPress "" e crie um. diretório /scripts.

Linux
```
unzip master.zip -d /tmp/WordPress_Temp
cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
rm -rf /tmp/WordPress_Temp
rm -f master
cd /tmp/WordPress
mkdir scripts
```
Windows: vá para o diretório WordPress "" que você criou e crie um diretório de “scripts” lá.

Se você estiver em um ambiente Windows, certifique-se de definir o tipo de interrupção dos arquivos de script como Unix (LF). No Notepad ++, essa é uma opção na parte inferior direita da janela.
Crie o arquivo CodeDeploy appspec.yml no WordPress diretório (se estiver copiando o exemplo, verifique o recuo, cada espaço conta). IMPORTANTE: Certifique-se de que o caminho de “origem” esteja correto para copiar os WordPress arquivos (nesse caso, em seu WordPress diretório) para o destino esperado (/var/www/html/WordPress). No exemplo, o arquivo appspec.yml está no diretório com os WordPress arquivos, portanto, somente “/” é necessário. Além disso, mesmo que você tenha usado uma AMI RHEL para seu grupo de Auto Scaling, deixe a linha “os: linux” como está. Exemplo de arquivo appspec.yml:
```
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/config_wordpress.sh
      timeout: 300
      runas: root
  ApplicationStart:
    - location: scripts/start_server.sh
      timeout: 300
      runas: root
  ApplicationStop:
    - location: scripts/stop_server.sh
      timeout: 300
      runas: root
```
Crie scripts de arquivo bash no WordPress . diretório /scripts.

Primeiro, crie config_wordpress.sh com o conteúdo a seguir (se preferir, você pode editar o arquivo wp-config.php diretamente).

nota
DBNameSubstitua pelo valor fornecido no HA Stack RFC (por exemplo,wordpress).
DB_MasterUsernameSubstitua pelo MasterUsername valor fornecido no HA Stack RFC (por exemplo,admin).
DB_MasterUserPasswordSubstitua pelo MasterUserPassword valor fornecido no HA Stack RFC (por exemplo,p4ssw0rd).
DB_ENDPOINTSubstitua pelo nome DNS do endpoint nas saídas de execução do HA Stack RFC (por exemplo,). srt1cz23n45sfg.clgvd67uvydk.us-east-1.rds.amazonaws.com Você pode encontrar isso na GetRfcoperação (CLI: get-rfc --rfc-id RFC_ID) ou na página de detalhes do RFC do console AMS para o HA Stack RFC que você enviou anteriormente.
```
#!/bin/bash
chmod -R 755 /var/www/html/WordPress
cp /var/www/html/WordPress/wp-config-sample.php /var/www/html/WordPress/wp-config.php
cd /var/www/html/WordPress
sed -i "s/database_name_here/DBName/g" wp-config.php
sed -i "s/username_here/DB_MasterUsername/g" wp-config.php
sed -i "s/password_here/DB_MasterUserPassword/g" wp-config.php
sed -i "s/localhost/DB_ENDPOINT/g" wp-config.php
```
No mesmo diretório, crie install_dependencies.sh com o seguinte conteúdo:
```
#!/bin/bash
yum install -y php
yum install -y php-mysql
yum install -y mysql
service httpd restart
```
nota
O HTTPS é instalado como parte dos dados do usuário no lançamento para permitir que as verificações de saúde funcionem desde o início.

No mesmo diretório, crie start_server.sh com o seguinte conteúdo:

Para instâncias do Amazon Linux, use isso:
```
#!/bin/bash
service httpd start
```

Para instâncias do RHEL, use isso (os comandos extras são políticas que permitem que o SELINUX aceite): WordPress


#!/bin/bash
setsebool -P  httpd_can_network_connect_db 1
setsebool -P  httpd_can_network_connect 1
chcon -t httpd_sys_rw_content_t /var/www/html/WordPress/wp-content -R
restorecon -Rv /var/www/html
service httpd start

No mesmo diretório, crie stop_server.sh com o seguinte conteúdo:
```
#!/bin/bash
service httpd stop
```
Crie o pacote zip.

Linux
```
$ cd /tmp/WordPress
$ zip -r wordpress.zip .
```
Windows: Vá para o diretório WordPress "", selecione todos os arquivos e crie um arquivo zip, não se esqueça de chamá-lo de wordpress.zip.

Implante o pacote de WordPress aplicativos com CodeDeploy

CodeDeploy É um serviço de implantação da AWS que automatiza implantações de aplicativos em instâncias da Amazon EC2 . Essa parte do processo envolve a criação de um CodeDeploy aplicativo, a criação de um grupo de CodeDeploy implantação e, em seguida, a implantação do aplicativo usando CodeDeploy.

Criar um CodeDeploy aplicativo

O CodeDeploy aplicativo é simplesmente um nome ou contêiner usado pela AWS CodeDeploy para garantir que a revisão, a configuração de implantação e o grupo de implantação corretos sejam referenciados durante uma implantação. A configuração de implantação, nesse caso, é o WordPress pacote que você criou anteriormente.

DADOS NECESSÁRIOS:

VpcId: a VPC que você está usando, deve ser a mesma que a VPC usada anteriormente.
CodeDeployApplicationName: deve ser exclusivo na conta. Consulte o CodeDeploy console para verificar os nomes dos aplicativos existentes.
ChangeTypeIdeChangeTypeVersion: O ID do tipo de alteração para este passo a passo éct-0ah3gwb9seqk2, para descobrir a versão mais recente, execute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0ah3gwb9seqk2
```

Exiba os parâmetros de execução do esquema JSON do CodeDeploy aplicativo CT para um arquivo na sua pasta atual; o exemplo o chama de Create CDApp Params.json.
```
aws amscm get-change-type-version --change-type-id "ct-0ah3gwb9seqk2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateCDAppParams.json
```

Modifique e salve o arquivo JSON da seguinte forma; você pode excluir e substituir o conteúdo.


{
"Description":                      "Create WordPress CodeDeploy App",
"VpcId":                            "VPC_ID",
"StackTemplateId":                  "stm-sft6rv00000000000",
"Name":                             "WordPressCDApp",
"TimeoutInMinutes":                 60,
"Parameters":   {
    "CodeDeployApplicationName":    "WordPressCDApp"
    }
}

Envie o modelo JSON CreateRfc para um arquivo em sua pasta atual; o exemplo o chama de Create CDApp RFC.json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDAppRfc.json
```
Modifique e salve o arquivo JSON da seguinte forma; você pode excluir e substituir o conteúdo. Observe que RequestedStartTime agora RequestedEndTime são opcionais; excluí-los faz com que o RFC seja executado assim que for aprovado (o que geralmente acontece automaticamente). Para enviar um RFC “agendado”, adicione esses valores.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0ah3gwb9seqk2",
"Title":                "CD-App-For-WP-Stack-RFC"
}
```
Crie o RFC, especificando o arquivo Create CDApp Rfc e o arquivo de parâmetros de execução:
```
aws amscm create-rfc --cli-input-json file://CreateCDAppRfc.json --execution-parameters file://CreateCDAppParams.json
```
Você recebe o ID de RFC do novo RFC na resposta. Salve o ID para as etapas subsequentes.
Envie o RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se o RFC for bem-sucedido, você não receberá nenhuma saída.
Envie o RFC:
```
aws amscm get-rfc --rfc-id RFC_ID
```

Criar um grupo CodeDeploy de implantação

Crie o grupo CodeDeploy de implantação.

Um grupo de CodeDeploy implantação define um conjunto de instâncias individuais destinadas a uma implantação.

DADOS NECESSÁRIOS:

VpcId: a VPC que você está usando, deve ser a mesma que a VPC usada anteriormente.
CodeDeployApplicationName: use o valor que você criou anteriormente.
CodeDeployAutoScalingGroups: use o nome do grupo Auto Scaling que você criou anteriormente.
CodeDeployDeploymentGroupName: um nome para o grupo de implantação. Esse nome deve ser exclusivo para cada aplicativo associado ao grupo de implantação.
CodeDeployServiceRoleArn: Use a fórmula fornecida no exemplo.
ChangeTypeIdeChangeTypeVersion: O ID do tipo de alteração para este passo a passo éct-2gd0u847qd9d2, para descobrir a versão mais recente, execute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2gd0u847qd9d2
```

Envie os parâmetros de execução do esquema JSON para um arquivo em sua pasta atual; o exemplo o chama de Create CDDep GroupParams .json.


aws amscm get-change-type-version --change-type-id "ct-2gd0u847qd9d2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateCDDepGroupParams.json

Modifique e salve o arquivo JSON da seguinte forma; você pode excluir e substituir o conteúdo.


{
"Description":                      "CreateWPCDDeploymentGroup",
"VpcId":                            "VPC_ID",
"StackTemplateId":                  "stm-sp9lrk00000000000",
"Name":                             "WordPressCDAppGroup",
"TimeoutInMinutes":                 60,
"Parameters":   {
    "CodeDeployApplicationName":        "WordPressCDApp",
    "CodeDeployAutoScalingGroups":      ["ASG_NAME"],
    "CodeDeployDeploymentConfigName":   "CodeDeployDefault.HalfAtATime",
    "CodeDeployDeploymentGroupName":    "UNIQUE_CDDepGroupNAME",
    "CodeDeployServiceRoleArn":         "arn:aws:iam::ACCOUNT_ID:role/aws-codedeploy-role"
    }
}

Envie o modelo JSON CreateRfc para um arquivo em sua pasta atual; o exemplo o chama de Create CDDep GroupRfc .json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDDepGroupRfc.json
```
Modifique e salve o arquivo JSON da seguinte forma; você pode excluir e substituir o conteúdo. Observe que RequestedStartTime agora RequestedEndTime são opcionais; excluí-los faz com que o RFC seja executado assim que for aprovado (o que geralmente acontece automaticamente). Para enviar um RFC “agendado”, adicione esses valores.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-2gd0u847qd9d2",
"Title":                "CD-Dep-Group-For-WP-Stack-RFC"
}
```
Crie o RFC, especificando o CDDep GroupRfc arquivo Create e o arquivo de parâmetros de execução:
```
aws amscm create-rfc --cli-input-json file://CreateCDDepGroupRfc.json --execution-parameters file://CreateCDDepGroupParams.json
```
Você recebe o ID de RFC do novo RFC na resposta. Salve o ID para as etapas subsequentes.
Envie o RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se o RFC for bem-sucedido, você não receberá nenhuma saída.
Verifique o status do RFC:
```
aws amscm get-rfc --rfc-id RFC_ID
```

Faça o upload do WordPress aplicativo

Você tem acesso automático a qualquer instância de bucket do S3 que você criar. Você pode acessá-lo por meio de seu Bastions (consulte Acesso a instâncias) ou por meio do console S3 e fazer o upload do CodeDeploy pacote. O pacote precisa estar pronto para continuar implantando a pilha. O exemplo usa o nome do bucket criado anteriormente.


aws s3 cp wordpress/wordpress.zip s3://ACCOUNT_ID-codedeploy-bundles/

Implante o WordPress aplicativo com CodeDeploy

Implante o CodeDeploy aplicativo.

Depois de ter seu pacote de CodeDeploy aplicativos e grupo de implantação, use esse RFC para implantar o aplicativo.

DADOS NECESSÁRIOS:

VPC-ID: a VPC que você está usando deve ser a mesma que a VPC usada anteriormente.
CodeDeployApplicationName: use o nome do CodeDeploy aplicativo que você criou anteriormente.
CodeDeployDeploymentGroupName: use o nome do grupo de CodeDeploy implantação que você criou anteriormente.
S3Location(onde você fez o upload do pacote de aplicativos)S3Bucket:: O BucketName que você criou anteriormente S3BundleType eS3Key: O tipo e o nome do pacote que você colocou na sua loja do S3.
ChangeTypeIdeChangeTypeVersion: O ID do tipo de alteração para este passo a passo éct-2edc3sd1sqmrb, para descobrir a versão mais recente, execute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2edc3sd1sqmrb
```

Envie o esquema JSON dos parâmetros de execução para a CT de implantação do CodeDeploy aplicativo em um arquivo na sua pasta atual; o exemplo o chama de Deploy CDApp Params.json.
```
aws amscm get-change-type-version --change-type-id "ct-2edc3sd1sqmrb" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeployCDAppParams.json
```

Modifique o arquivo JSON da seguinte forma; você pode excluir e substituir o conteúdo. ParaS3Bucket, use o BucketName que você criou anteriormente.


{
"Description":                      "Deploy WordPress CodeDeploy Application",
"VpcId":                            "VPC_ID",
"Name":                             "WP CodeDeploy Deployment Group",
"TimeoutInMinutes":                 60,
"Parameters":   {
    "CodeDeployApplicationName":        "WordPressCDApp",
    "CodeDeployDeploymentGroupName":    "WordPressCDDepGroup",
    "CodeDeployIgnoreApplicationStopFailures": false,
    "CodeDeployRevision": {
      "RevisionType": "S3",
      "S3Location": {
        "S3Bucket": "ACCOUNT_ID.BUCKET_NAME",
        "S3BundleType": "zip",
        "S3Key": "wordpress.zip" }
        }
    }
}

Envie o modelo JSON CreateRfc para um arquivo em sua pasta atual; o exemplo o chama de Deploy CDApp RFC.json:
```
aws amscm create-rfc --generate-cli-skeleton > DeployCDAppRfc.json
```

Modifique e salve o arquivo Deploy CDApp RFC.json; você pode excluir e substituir o conteúdo.


{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-2edc3sd1sqmrb",
"Title":                "CD-Deploy-For-WP-Stack-RFC",
"RequestedStartTime":   "2017-04-28T22:45:00Z",
"RequestedEndTime":     "2017-04-28T22:45:00Z"
}

Crie o RFC, especificando o arquivo de parâmetros de execução e o arquivo Deploy CDApp Rfc:
```
aws amscm create-rfc --cli-input-json file://DeployCDAppRfc.json  --execution-parameters file://DeployCDAppParams.json
```
Você recebe o RfcId do novo RFC na resposta. Salve o ID para as etapas subsequentes.
Envie o RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se o RFC for bem-sucedido, você não receberá nenhuma saída.

Validar a implantação do aplicativo

Navegue até o endpoint (ELB CName) do balanceador de carga criado anteriormente, com o caminho WordPress implantado:/. WordPress Por exemplo:


http://stack-ID-FOR-ELB.us-east-1.elb.amazonaws.com/WordPress

Acabe com a implantação de aplicativos

Para reduzir a implantação, você envia o Delete Stack CT contra a pilha de banco de dados do RDS, o balanceador de carga do aplicativo, o grupo Auto Scaling, o bucket S3 e o aplicativo e grupo Code Deploy — seis no total. RFCs Além disso, você pode enviar uma solicitação de serviço para que os instantâneos do RDS sejam excluídos (eles são excluídos automaticamente após dez dias, mas custam uma pequena quantia enquanto estão lá). Reúna a pilha IDs para todos e siga estas etapas.

Este passo a passo fornece um exemplo do uso do console AMS para excluir uma pilha do S3; esse procedimento se aplica à exclusão de qualquer pilha usando o console do AMS.

nota

Se você excluir um bucket do S3, primeiro ele deverá ser esvaziado de objetos.

DADOS NECESSÁRIOS:

StackId: A pilha a ser usada. Você pode encontrar isso acessando a página AMS Console Stacks, disponível por meio de um link no painel de navegação esquerdo. Usando a API/CLI do AMS SKMS, execute a referência da API Para o AMS SKMS, consulte a guia Relatórios no AWS Artifact Console. operação (na CLI). list-stack-summaries
O ID do tipo de alteração para este passo a passo éct-0q0bic0ywqk6c: a versão é “1.0". Para descobrir a versão mais recente, execute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0q0bic0ywqk6c
```

CRIAÇÃO EM LINHA:

Execute o comando create RFC com os parâmetros de execução fornecidos em linha (aspas de escape ao fornecer parâmetros de execução em linha). E


aws amscm create-rfc --change-type-id "ct-0q0bic0ywqk6c" --change-type-version "1.0" --title "Delete My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"

Envie a RFC usando a ID da RFC retornada na operação de criação da RFC. Até ser enviada, a RFC permanece no Editing estado e não é aplicada.
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Monitore o status da RFC e visualize a saída da execução:
```
aws amscm get-rfc --rfc-id RFC_ID
```

CRIAÇÃO DE MODELO:

Envie o modelo RFC para um arquivo em sua pasta atual; o exemplo o chama de DeleteStackRfc .json:
```
aws amscm create-rfc --generate-cli-skeleton > DeleteStackRfc.json
```
Modifique e salve o DeleteStackRfc arquivo.json. Como a exclusão de uma pilha tem apenas um parâmetro de execução, os parâmetros de execução podem estar no próprio DeleteStackRfc arquivo.json (não há necessidade de criar um arquivo JSON separado com parâmetros de execução).

As aspas internas na extensão ExecutionParameters JSON devem ser excluídas com uma barra invertida (\). Exemplo sem horário de início e término:
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0q0bic0ywqk6c",
"Title":                "Delete-My-Stack-RFC"
"ExecutionParameters":  "{
        \"StackId\":\"STACK_ID\"}"
}
```

Crie o RFC:


aws amscm create-rfc --cli-input-json file://DeleteStackRfc.json

Você recebe o RfcId do novo RFC na resposta. Por exemplo:


{
"RfcId": "daaa1867-ffc5-1473-192a-842f6b326102"
}

Salve o ID para as etapas subsequentes.

Envie o RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se o RFC for bem-sucedido, você não receberá nenhuma confirmação na linha de comando.

Para monitorar o status da solicitação e visualizar a Saída de Execução:


aws amscm get-rfc --rfc-id RFC_ID --query "Rfc.{Status:Status.Name,Exec:ExecutionOutput}" --output table

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

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

Convenções do documento

Elimine a implantação de aplicativos

Crie a infraestrutura