Implementação de rede automatizada: como criar uma VPN entre o GCP e a AWS

Neste tutorial, você aprende a usar o Terraform da HashiCorp para criar conexões seguras, privadas e de site a site, entre o Google Cloud Platform (GCP) e o Amazon Web Services (AWS), usando redes privadas virtuais (VPNs, na sigla em inglês). Esta é uma implantação em diversas nuvens.

Este tutorial é o terceiro de uma série de três partes que demonstra a implantação automatizada de padrões comuns dos recursos de rede. O tutorial depende da autenticação e da configuração do projeto descritas no tutorial Visão geral da implantação da rede automatizada.

Neste tutorial, você implanta instâncias da máquina virtual (VM) em redes de nuvem privada virtual (VPC, na sigla em inglês) personalizadas no GCP e AWS, bem como uma infraestrutura compatível para construir uma conexão VPN com dois túneis do Protocolo de segurança IP (IPsec) entre as redes VPC no GCP e AWS. O ambiente e a implantação do túnel são geralmente concluídos em quatro minutos.

Esta é uma extensão do tutorial Implantação da rede automatizada: inicialização, porém ela não inclui uma configuração do Deployment Manager porque os recursos são implantados em provedores fora do GCP. Em vez disso, para implantar recursos usando provedores de nuvem pública, incluindo o GCP, este tutorial usa arquivos de configuração do Terraform. As implantações em várias nuvens estão além do escopo pretendido do Deployment Manager.

Custos

Este tutorial usa os seguintes componentes faturáveis do GCP e AWS:

instâncias do Compute Engine e do Amazon Elastic Compute Cloud (Amazon EC2)
instâncias de diversas VCPUs compatíveis com uma taxa maior de transferência de rede
armazenamento em disco permanente e em blocos
saída de rede
túneis VPN

O tráfego de saída a partir de instâncias da VM está sujeito a limites máximos de capacidade de saída da rede. Este tutorial usa diversos tipos de máquinas de VCPUs para liberar espaço ao tráfego de saída da rede.

Use a Calculadora de preços para gerar uma estimativa de custo com base na projeção de uso.

Antes de começar

Selecione o projeto GCP chamado gcp-automated-networks.

Acessar a página Projetos
Inicie uma instância do Cloud Shell. Todos os comandos do terminal neste tutorial são executados a partir do Cloud Shell.

Abrir o Cloud Shell

Arquitetura de implantação

Neste tutorial, você cria o ambiente de implantação abaixo.

ambiente de implantação

Este tutorial vai ajudá-lo a:

criar redes VPC personalizadas com blocos CIDR especificados pelo usuário em GCP e AWS;
implantar uma instância VM em cada rede VPC;
criar gateways VPN em cada rede VPC e recursos relacionados para dois túneis do IPsec.

Enquanto o GCP utiliza rotas compatíveis com o roteamento de vários caminhos de igual custo (ECMP, na sigla em inglês), o AWS é compatível com gateways VPN em dois túneis, ativo e em espera, para redundância e disponibilidade.

Roteamento

A configuração do tutorial utiliza o Cloud Router para demonstrar o roteamento dinâmico. O Cloud Router troca as atualizações da rota de rede VPC com o ambiente no AWS usando o Border Gateway Protocol (BGP). O roteamento dinâmico requer um Cloud Router separado para cada túnel IPsec. Como alternativa, faça a configuração com rotas estáticas. Ambas as configurações são abordadas no Guia de Interoperabilidade do Cloud VPN.

Como preparar o ambiente de trabalho do GCP

Nesta seção, você:

clona o código do tutorial;
verifica a região e zona do seu GCP.

Clonar o código do tutorial

Clone o código do tutorial do GitHub:

git clone https://github.com/GoogleCloudPlatform/autonetdeploy-multicloudvpn.git

Navegue até o diretório do tutorial:
```
cd autonetdeploy-multicloudvpn
```

Verificar a região e zona do GCP

Certos recursos de nuvem neste tutorial, incluindo instâncias do Compute Engine, gateways VPN e o Cloud Router, exigem a declaração explícita da região ou zona de posicionamento pretendida, ou ambas. Para mais detalhes, consulte Regiões e zonas para o GCP.

Este tutorial requer apenas uma única região para cada provedor. Para otimizar a conexão entre as duas nuvens, escolha regiões próximas uma da outra. A tabela a seguir lista os valores configurados nos arquivos de tutorial terraform/gcp_variables.tf e terraform/aws_variables.tf.

Nome do campo	Valores GCP	Valores AWS
`Region Name`	`us-west1`	`US West (us-west-2)`
`Location`	`The Dalles, Oregon, USA`	`Oregon`

Como se preparar para usar o AWS

Nesta seção, você verifica a região do seu AWS. Para detalhes sobre as regiões da AWS, consulte Regiões e zonas de disponibilidade para a AWS.

Faça login no console de Gerenciamento da AWS e acesse o Painel da VPC. Selecione a região do Oregon usando o menu suspenso.
No Painel EC2 e no Painel VPC, revise os recursos usados por este tutorial.

Como preparar o Terraform

Nesta seção, você faz o download do executável do Terraform.

No Cloud Shell, execute o seguinte script:
```
./get_terraform.sh
```
Este script faz o download e descompacta o binário executável da ferramenta Terraform para o diretório ~/terraform. A saída do script mostra um comando de exportação para atualizar seu PATH. Com o PATH atualizado, verifique o funcionamento do seu Terraform:
```
terraform --help
```
Resultado:
```
Usage: terraform [--version] [--help] [command] [args]
...
```

Consulte os tópicos Fazer o download do Terraform e Instalar o Terraform se precisar de ajuda.

Como criar credenciais de acesso para o GCP e AWS

Você criou as credenciais no tutorial Visão geral. No entanto, é preciso registrar suas credenciais com o Terraform.

Faça o registro de suas credenciais GCP com o Terraform:

./gcp_set_credentials.sh exists

Resultado:

Updated gcp_credentials_file_path in ~/autonetdeploy-multicloudvpn/terraform/terraform.tfvars.

Faça o registro de suas credenciais AWS com o Terraform:

./aws_set_credentials.sh exists

Resultado:

Updated aws_credentials_file_path in ~/autonetdeploy-multicloudvpn/terraform/terraform.tfvars.

Como configurar seu projeto

Há diversas maneiras apresentadas pelo GCP para designar projetos a serem usados pelas ferramentas de automação. Por simplicidade, em vez de extrair o código do projeto do ambiente, o projeto GCP é explicitamente identificado por uma variável de string nos arquivos de modelo.

Configure o código do projeto.

gcloud config set project [YOUR-PROJECT-ID]

Resultado:

Updated property [core/project].

Use o script fornecido para atualizar o valor do projeto em seu arquivo de configuração para o Terraform.
```
./gcp_set_project.sh
```
Resultado:
```
Updated gcp_project_id in /home/[USER]/autonetdeploy-gcpawsvpn/terraform/terraform.tfvars.
```
Revise o arquivo atualizado, terraform/terraform.tfvars, para verificar se o project-id foi inserido.
Execute o comando único terraform init para instalar os provedores do Terraform desta implantação.
```
pushd ./terraform && terraform init && popd > /dev/null
```

Execute o comando plan do Terraform para verificar suas credenciais.

pushd ./terraform && terraform plan && popd > /dev/null

Caso você não veja o texto com erro em vermelho, sua autenticação está funcionando corretamente.

Resultado:

Refreshing Terraform state in-memory prior to plan...
...
 +google_compute_instance.gcp-vm
...
Plan: 34 to add, 0 to change, 0 to destroy.

Como examinar arquivos de configuração do Terraform

No Terraform, uma configuração de implantação é definida por um diretório de arquivos. Esses arquivos podem estar no formato JSON, mas é melhor usar a sintaxe do arquivo de configuração do Terraform (.tf) porque ela é mais fácil de ler e manter. Este tutorial fornece um conjunto de arquivos que ilustra um forma mais limpa de organizar seus recursos. Esse conjunto é uma implantação funcional e não requer nenhuma edição para ser executado.

Nome do arquivo	Finalidade
`main.tf`	Define seus provedores e especifica as nuvens a serem implantadas nesta configuração. Também lê suas credenciais, nome do projeto e regiões selecionadas.
`gcp_variables.tf`, `aws_variables.tf`	Declara variáveis usadas para parametrizar e personalizar a implantação, por exemplo, `gcp_region` e `gcp_instance_type`.
`gcp_compute.tf`, `aws_compute.tf`	Define os recursos de computação usados em sua implantação, por exemplo, `google_compute_instance`.
`vm_userdata.sh`	Especifica o script a ser executado ao iniciar instâncias da VM. Configura automaticamente a ferramenta de teste `iperf3` e alguns scripts de wrapper.
`gcp_networking.tf`, `aws_networking.tf`	Define recursos de rede, incluindo `google_compute_network`, `google_compute_subnetwork`, `google_compute_address`, `google_compute_vpn_gateway` e `google_compute_vpn_tunnel`.
`gcp_security.tf`, `aws_security.tf`	Define recursos para permitir o tráfego de teste no ambiente do GCP ou AWS, incluindo regras de `google_compute_firewall` e recursos de `aws_security_group`.
`gcp_outputs.tf`, `aws_outputs.tf`	Define variáveis a serem enviadas após a conclusão da implantação, por exemplo, o `external_ip` e `internal_ip` da instância da VM implantada.
`terraform.tfstate`	[RESULTADO]. Especifica o arquivo usado pelo Terraform para armazenar o estado do recurso do lado do cliente após verificação com a nuvem. Para mais detalhes, consulte Como gerenciar projetos do GCP com o Terraform.
`run_graph.sh`	Script de shell para gerar um arquivo PNG a partir do Terraform, mostrando dependências de recursos. Veja a saída deste script em images/gcpawsvpn_plan_graph.png.

Neste tutorial, você usa os scripts para criar o arquivo terraform.tfvars, que inclui a configuração específica do usuário para credentials e gcp_project_id.

Como implantar redes VPC, instâncias VM, gateways VPN e túneis IPsec

Construir conexões entre diversas nuvens é complexo. É possível implantar muitos recursos em paralelo nos dois ambientes, mas ao criar túneis IPsec, é preciso organizar interdependências cuidadosamente. Por esse motivo, estabelecer no código uma configuração de implantação estável é uma maneira útil de dimensionar seu conhecimento de implantação. A figura abaixo resume as etapas necessárias para criar esta configuração de implantação em diversos provedores.

etapas da implantação

Implantar com o Terraform

O Terraform usa o arquivo terraform.tfstate para capturar o estado do recurso. Para ver o estado atual do recurso de modo legível, execute terraform show.

Para a autenticação correta do Terraform com seus provedores, você precisa primeiro concluir o tutorial Visão geral. Configure o Terraform antes de passar às etapas seguintes.

No Cloud Shell, navegue até o diretório terraform:
```
pushd terraform
```
Use o comando validate do Terraform para validar a sintaxe dos arquivos de configuração. Esta verificação de validação é mais simples do que as realizadas como parte dos comandos plan e apply nas etapas subsequentes. Nenhum provedor é autenticado com o comando validate.
```
terraform validate
```
Quando não é exibida uma mensagem de erro, é porque você concluiu uma validação inicial da sintaxe do arquivo e da semântica básica. Do contrário, a validação da mensagem falhou.
Use o comando plan do Terraform para analisar a implantação sem instanciar recursos na nuvem. O comando plan requer autenticação bem-sucedida com todos os provedores especificados na configuração.
```
terraform plan
```
O comando plan retorna uma lista de recursos de saída a serem adicionados, removidos ou atualizados. A última linha de saída do plan mostra uma contagem de recursos a serem adicionados, alterados ou destruídos:
```
Refreshing Terraform state in-memory prior to plan...
...
Plan: 34 to add, 0 to change, 0 to destroy.
```
Se quiser, use o comando graph do Terraform para visualizar as dependências dos recursos. Com o gráfico de dependências você analisa os recursos implantados. Veja uma versão previamente preparada do arquivo de saída em images/gcpawsvpn_plan_graph.png.

O script run_graph.sh cria o arquivo PNG ./gcpawsvpn_plan_graph.png, que terá uma aparência semelhante a esta:

O script run_graph.sh depende do pacote graphviz. Se graphviz não estiver instalado, você verá uma mensagem dot: command not found. No Cloud Shell, instale o graphviz com o seguinte comando:
```
sudo apt-get install graphviz
```
Use o comando apply do Terraform para criar uma implantação:
```
terraform apply
```
O comando apply cria uma implantação com recursos de suporte na nuvem. Em cerca de quatro minutos, o comando apply cria mais de 30 recursos, incluindo redes VPC, instâncias de VM, gateways de VPN e túneis IPsec do GCP e da AWS. A saída do comando apply inclui detalhes dos recursos implantados e as variáveis de saída definidas pela configuração.
```
data.google_compute_zones.available: Refreshing state...
...
Apply complete! Resources: 34 added, 0 changed, 0 destroyed.
...
Outputs:

aws_instance_external_ip = [AWS_EXTERNAL_IP]
aws_instance_internal_ip = 172.16.0.100
gcp_instance_external_ip = [GCP_EXTERNAL_IP]
gcp_instance_internal_ip = 10.240.0.100
```
Caso seja preciso atualizar o estado final esperado de sua configuração, edite seus arquivos .tf. Adicione a porta 23 à sua regra google_compute_firewall gcp_allow-ssh editando gcp_security.tf:
```
ports = ["22", "23"]
```
O Terraform analisa as edições e identifica as alterações mínimas necessárias para atualizar seu estado de implantação para haver correspondência.
```
terraform apply
```
O Terraform modifica gcp-network-gcp-allow-ssh para a configuração atualizada.
Suas implantações podem emitir variáveis de saída para auxiliar seu fluxo de trabalho. Neste tutorial, os endereços IP internos e externos atribuídos das instâncias da VM foram identificados como variáveis de saída pelos arquivos gcp_outputs.tf e aws_outputs.tf. Estes endereços são impressos automaticamente quando a etapa apply é concluída. Se você quiser exibir novamente os valores das variáveis de saída posteriormente no fluxo de trabalho, use o comando output.
```
terraform output
```
As variáveis de saída definidas por esta configuração incluem os endereços IP internos e externos das suas instâncias da VM. Para usar o comando ssh na validação de rede, você precisa dos endereços IP externos para se conectar às instâncias da VM.
```
aws_instance_external_ip = [AWS_EXTERNAL_IP]
aws_instance_internal_ip = 172.16.0.100
gcp_instance_external_ip = [GCP_EXTERNAL_IP]
gcp_instance_internal_ip = 10.240.0.100
```
Use o comando show do Terraform para inspecionar os recursos implantados e verificar o estado atual.
```
terraform show
```
Resultado:
```
...
google_compute_instance.gcp-vm:
...
Outputs:
...
```

Para revisar suas instâncias, use gcloud compute instances list ou o Console do Cloud no painel de instâncias da VM.

gcloud compute instances list

Resultado:

NAME             ZONE        MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP    EXTERNAL_IP    STATUS
gcp-vm-us-west1  us-west1-a  n1-highmem-8               10.240.0.100   [EXTERNAL IP]  RUNNING

Verifique se sua instância da VM no GCP está funcionando usando o comando ssh para se conectar a ela:
```
ssh -i ~/.ssh/vm-ssh-key [GCP_EXTERNAL_IP]
```
Execute os comandos ping e curl em sua sessão ssh:
```
ping -c 5 google.com
curl ifconfig.co/ip
```
Execute verificações simples de desempenho de rede a partir da instância da VM no GCP. Use scripts pré-instalados para executar um teste em cada interface de rede, externa e interna.
1. Sobre IPs externos:
```
/tmp/run_iperf_to_ext.sh
```
  Este script executa um teste de desempenho de 30 segundos que produz dados resumidos sobre o desempenho da rede.
  
  Resultado:
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
2. Sobre VPN (IPs internos):
```
/tmp/run_iperf_to_int.sh
```
  Este script executa um teste de desempenho de 30 segundos que produz dados resumidos sobre o desempenho da rede.
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
Quando você completar as verificações da instância da VM no GCP, digite o seguinte comando:
```
exit
```
Para verificar o funcionamento da sua instância da VM no AWS, use o comando ssh para se conectar a ela:
```
ssh -i ~/.ssh/vm-ssh-key ubuntu@[AWS_EXTERNAL_IP]
```
Execute os comandos ping e curl em sua sessão ssh:
```
ping -c 5 google.com
curl ifconfig.co/ip
```
Execute verificações simples de desempenho de rede a partir da instância da VM do AWS. Use scripts pré-instalados para executar um teste em cada interface de rede, externa e interna.
1. Sobre IPs externos:
```
/tmp/run_iperf_to_ext.sh
```
  Este script executa um teste de desempenho de 30 segundos que produz dados resumidos sobre o desempenho da rede.
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
2. Sobre VPN (IPs internos):
```
/tmp/run_iperf_to_int.sh
```
  Este script executa um teste de desempenho de 30 segundos que produz dados resumidos sobre o desempenho da rede.
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
Ao concluir as verificações a partir da instância da VM do AWS, digite o seguinte comando:
```
exit
```

Você implantou com sucesso uma conexão segura, particular, de site a site entre o GCP e o AWS usando a VPN.

Limpeza

Limpe os recursos implantados. Você continuará a ser cobrado por suas instâncias da VM até executar o comando de implantação destroy.

Execute o comando opcional plan -destroy para revisar os recursos afetados por destroy:

terraform plan -destroy

Resultado:

Refreshing Terraform state in-memory prior to plan...
...
Plan: 0 to add, 0 to change, 34 to destroy.

Como o comando destroy excluirá permanentemente seus recursos, é preciso confirmar suas intenções digitando yes. O comando destroy geralmente é concluído em cerca de 100 segundos:
```
terraform destroy
```
Resultado:
```
Do you really want to destroy?
  Terraform will delete all your managed infrastructure.
  There is no undo. Only 'yes' will be accepted to confirm.
    Enter a value: yes
```
Digite yes para confirmar a destruição do recurso criado por você.
```
Destroy complete! Resources: 34 destroyed.
```
Execute o comando show para exibir o estado dos recursos:
```
terraform show
```
Como você destruiu todos os recursos, o comando show não exibirá linhas, indicando que não restou recurso algum implantado.
Finalmente, restaure seu diretório:
```
popd > /dev/null
```

Você já concluiu com sucesso a implantação e a limpeza de uma conexão segura, privada, de site a site, entre instâncias no GCP e AWS.

A seguir

Para saber mais sobre um método mais avançado de armazenar seu arquivo de estado do Terraform no Cloud Storage, leia Como gerenciar projetos do GCP com o Terraform.
Para saber mais sobre o Open Cloud, leia E se você pudesse executar tudo em qualquer ambiente? (Como escapar da dependência de fornecedor com uma pilha de várias nuvens).
Para saber mais sobre o Open Cloud e as configurações híbridas, assista ao Keynote do dia 3, com Vint Cerf e Sam Ramji no Google Cloud Next, a partir de março de 2017.
Para revisar detalhes no Cloud VPN, consulte:
Teste outros recursos do Google Cloud Platform. Veja os tutoriais.