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ê implantará instâncias de máquina virtual (VM) em redes de nuvem privada virtual (VPC) personalizadas no GCP e na AWS. Em seguida, implante a infraestrutura de suporte para construir uma conexão VPN com dois túneis IPsec (Internet Protocol security) entre o GCP e as redes VPC da AWS. O ambiente e a implantação do túnel são geralmente concluídos em quatro minutos.

Embora este tutorial seja uma extensão do tutorial Implantação de rede automatizada: inicialização , ele 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 vários 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 VCPU 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 do 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.

Abra 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. Na tabela a seguir, listamos os valores definidos 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 script a seguir:
```
./get_terraform.sh
```
Esse 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 o PATH. Depois de atualizar seu PATH, verifique se o Terraform está funcionando:
```
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

Saída:

Updated gcp_project_id in /home/[USER]/autonetdeploy-gcpawsvpn/terraform/terraform.tfvars.

Analise o arquivo atualizado, terraform/terraform.tfvars, para verificar se project-id foi inserido.
Execute o comando único terraform init para instalar os provedores do Terraform para essa 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 (em inglês) (.tf) porque ela é mais fácil de ler e manter. Veja neste tutorial uma maneira clara de organizar seus recursos, ilustrada em um conjunto de arquivos. 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 da AWS, incluindo regras `google_compute_firewall` e recursos `aws_security_group`.
`gcp_outputs.tf`, `aws_outputs.tf`	Define variáveis a serem exibidas após a conclusão da implantação, por exemplo, `external_ip` e `internal_ip` da instância de 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, em que está incluída 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 forma 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. Essa 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 Terraform plan 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. Na última linha do resultado de plan é exibida 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 (em inglês) do Terraform para visualizar as dependências dos recursos. O gráfico de dependências ajuda a analisar os recursos implantados. É possível ver uma versão preparada anteriormente 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 é semelhante ao seguinte:

O script run_graph.sh depende do pacote graphviz (em inglês). Se graphviz não estiver instalado, você verá uma mensagem dot: command not found. No Cloud Shell, instale o graphviz usando 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, apply cria mais de 30 recursos, incluindo as redes VPC do GCP e da AWS, as instâncias de VM, os gateways VPN e os túneis IPsec (links em inglês). 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 necessário atualizar o estado final esperado da configuração, edite os 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.
Variáveis de saída podem ser emitidas pelas implantações para auxiliar o fluxo de trabalho. Neste tutorial, os endereços IP internos e externos atribuídos das instâncias de VM foram identificados como variáveis de saída pelos arquivos gcp_outputs.tf e aws_outputs.tf. Esses 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 (em inglês):
```
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 para validação de rede, você precisa dos endereços IP externos para se conectar às instâncias de 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 analisar suas instâncias, use gcloud compute instances list ou o Console do Cloud no painel Instâncias de VM.

gcloud compute instances list

Saída:

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 a instância de VM do 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 na sessão ssh:

ping -c 5 google.com
curl ifconfig.co/ip

Execute verificações simples de desempenho de rede na instância da VM do 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 se a instância da VM da AWS está funcionando, 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 na sessão ssh:

ping -c 5 google.com
curl ifconfig.co/ip

Execute verificações simples de desempenho de rede na instância da VM da 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á sendo cobrado pelas instâncias de VM até executar o comando de implantação destroy.

Execute o comando plan -destroy opcional para analisar 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, você precisa confirmar suas intenções inserindo yes. O comando destroy geralmente é concluído em cerca de 100 segundos:
```
terraform destroy
```
Saída:
```
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 que você criou.
```
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 gera linhas, indicando que nenhum recurso permanece 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. Veja nossos tutoriais.