Implementación automatizada de redes: crea una VPN entre GCP y AWS con Terraform

En este instructivo, se muestra cómo usar Terraform de HashiCorp para crear conexiones seguras y privadas de sitio a sitio entre Google Cloud Platform (GCP) y Amazon Web Services (AWS) mediante redes privadas virtuales (VPN). Esta es una implementación de múltiples nubes.

Este instructivo es la tercera de una serie de tres partes, en la que se demuestra la implementación automatizada de patrones de recursos de Herramientas de redes comunes. El instructivo se basa en la autenticación y la configuración del proyecto que se describen en el instructivo Implementación automatizada de redes: descripción general.

En este instructivo, implementarás instancias de máquina virtual (VM) en redes de nube privada virtual (VPC) personalizadas en GCP y AWS. Luego, implementarás la infraestructura de asistencia para construir una conexión de VPN con dos túneles de Protocolo de seguridad de Internet (IPsec) entre las redes de VPC de GCP y AWS. Por lo general, la implementación del túnel y el entorno se completa en cuatro minutos.

Si bien este instructivo es una extensión del instructivo Implementación automatizada de redes: inicio, no se incluye una configuración de Deployment Manager porque los recursos se implementan en proveedores externos a GCP. En cambio, en este instructivo, se usan archivos de configuración de Terraform para implementar recursos mediante varios proveedores de servicios en la nube pública, incluido GCP. Las implementaciones de múltiples nubes están fuera del alcance previsto para Deployment Manager.

Costos

En este instructivo, se usan los siguientes componentes facturables de GCP y AWS:

Instancias de Compute Engine y Amazon Elastic Compute Cloud (Amazon EC2)
Instancias de múltiples CPU virtuales para una mayor capacidad de procesamiento de red
Discos persistentes y almacenamiento en bloque
Salida de Herramientas de redes
Túneles VPN

El tráfico de salida de las instancias de VM está sujeto a la capacidad de procesamiento de salida de red máxima. En este instructivo, se usan varios tipos de máquina de CPU virtuales para darle lugar al tráfico de salida de red.

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

Selecciona el proyecto de GCP llamado gcp-automated-networks.

Ir a la página Proyectos
Inicia una instancia de Cloud Shell. Ejecuta todos los comandos de terminal en este instructivo desde Cloud Shell.

Abra Cloud Shell

Arquitectura de implementación

En este instructivo, compilarás el siguiente entorno de implementación.

entorno de implementación

En este instructivo, se describe cómo realizar las siguientes acciones:

Compilar redes de VPC personalizadas con bloques CIDR especificados por el usuario en GCP y AWS
Implementar una instancia de VM en cada red de VPC
Crear puertas de enlace de VPN en cada red de VPC y recursos relacionados para dos túneles IPsec

Si bien GCP usa rutas para la compatibilidad con el enrutamiento de múltiples rutas de igual costo (ECMP), AWS es compatible con las puertas de enlace de VPN con dos túneles (uno activo y otro en espera) para la redundancia y la disponibilidad.

Enrutamiento

En la configuración del instructivo, se usa Cloud Router para demostrar el enrutamiento dinámico. Cloud Router intercambia las actualizaciones de ruta de la red de VPC con el entorno en AWS mediante el Protocolo de puerta de enlace fronteriza (BGP). El enrutamiento dinámico de Cloud Router requiere un Cloud Router independiente para cada túnel IPsec. De manera alternativa, puedes determinar una configuración con rutas estáticas. En la Guía de interoperabilidad de Cloud VPN, se detallan ambas configuraciones.

Prepara el entorno de trabajo de GCP

En esta sección, harás lo siguiente:

Clonar el código del instructivo
Verificar la región y la zona de GCP

Clona el código del instructivo

Clona el código del instructivo desde GitHub:

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

Navega hacia el directorio del instructivo:
```
cd autonetdeploy-multicloudvpn
```

Verifica la región y la zona de GCP

Para algunos recursos de la nube en este instructivo, incluidas las instancias de Compute Engine, las puertas de enlace de VPN y Cloud Router, se requiere que declares de forma explícita la región o la zona de ubicación (o ambas) deseadas. Si quieres obtener más detalles, consulta Regiones y zonas para GCP.

En este instructivo, solo se necesita una región para cada proveedor. Para optimizar la conexión entre las dos nubes, elige regiones cercanas entre sí. En la siguiente tabla, se enumeran los valores establecidos en los archivos terraform/gcp_variables.tf y terraform/aws_variables.tf del instructivo.

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

Prepara AWS para su uso

En esta sección, podrás verificar tu región de AWS. Si quieres obtener detalles sobre las regiones de AWS, consulta Regiones y zonas de disponibilidad para AWS.

Accede a Consola de administración de AWS y navega hacia el Panel de VPC. Selecciona la región de Oregón mediante el menú desplegable.
En Panel de EC2 y Panel de VPC, revisa los recursos que se usan en este instructivo.

Prepara Terraform

En esta sección, podrás descargar el ejecutable de Terraform.

En Cloud Shell, ejecuta la siguiente secuencia de comandos:
```
./get_terraform.sh
```
Mediante esta secuencia de comandos, se descarga y se descomprime el objeto binario ejecutable de la herramienta de Terraform en el directorio ~/terraform. En el resultado de la secuencia de comandos, se muestra un comando de exportación para actualizar la PATH. Después de actualizar la PATH, verifica que Terraform esté en funcionamiento:
```
terraform --help
```
Resultado:
```
Usage: terraform [--version] [--help] [command] [args]
...
```

Si necesitas ayuda, consulta los temas Descarga Terraform y, también, Instala Terraform.

Crea credenciales de acceso de GCP y AWS

Ya creaste credenciales en el Instructivo de descripción general. Sin embargo, debes registrar tus credenciales con Terraform.

Registra tus credenciales de GCP con Terraform:

./gcp_set_credentials.sh exists

Resultado:

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

Registra tus credenciales de AWS con Terraform:

./aws_set_credentials.sh exists

Resultado:

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

Configura tu proyecto

GCP ofrece varias maneras de designar el proyecto de GCP que usarán las herramientas de automatización. Con el fin de hacerlo más simple, en vez de extraer el ID del proyecto desde el entorno, el proyecto de GCP se identifica de forma explícita a través de una string variable en los archivos de plantilla.

Determina tu ID del proyecto:

gcloud config set project [YOUR-PROJECT-ID]

Resultado:

Updated property [core/project].

Usa la secuencia de comandos proporcionada para actualizar el valor del proyecto en el archivo de configuración de Terraform.
```
./gcp_set_project.sh
```
Resultado:
```
Updated gcp_project_id in /home/[USER]/autonetdeploy-gcpawsvpn/terraform/terraform.tfvars.
```
Revisa el archivo actualizado, terraform/terraform.tfvars, para verificar que se haya insertado project-id.
Ejecuta el comando terraform init único a fin de instalar los proveedores de Terraform para esta implementación.
```
pushd ./terraform && terraform init && popd > /dev/null
```

Ejecuta el comando plan de Terraform para verificar las credenciales.

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

Si no ves ningún texto de error en rojo, la autenticación funciona de forma adecuada.

Resultado:

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

Examina los archivos de configuración de Terraform

En Terraform, se define una configuración de implementación mediante un directorio de archivos. Aunque estos archivos pueden ser JSON, es mejor usar la sintaxis del archivo de configuración de Terraform (archivo .tf), que es más fácil de leer y mantener. En este instructivo, se proporciona un conjunto de archivos que ilustran una forma de organizar tus recursos de forma clara. Este conjunto es una implementación funcional y no requiere modificaciones para ejecutarse.

Nombre del archivo	Propósito
`main.tf`	Define los proveedores y especifica qué nubes implementar en esta configuración. También lee las credenciales, el nombre del proyecto y las regiones seleccionadas.
`gcp_variables.tf`, `aws_variables.tf`	Declara las variables que se usan para configurar los parámetros de la implementación y personalizarla, por ejemplo, `gcp_region` y `gcp_instance_type`.
`gcp_compute.tf`, `aws_compute.tf`	Define los recursos de procesamiento que se usan en la implementación, por ejemplo, `google_compute_instance`.
`vm_userdata.sh`	Especifica la secuencia de comandos que se ejecutará cuando se inicien las instancias de VM. Determina de manera automática la herramienta de prueba `iperf3` y algunas secuencias de comandos del wrapper.
`gcp_networking.tf`, `aws_networking.tf`	Define los recursos de Herramientas de redes, incluidos `google_compute_network`, `google_compute_subnetwork`, `google_compute_address`, `google_compute_vpn_gateway` y `google_compute_vpn_tunnel`.
`gcp_security.tf`, `aws_security.tf`	Define recursos para permitir el tráfico de prueba en el entorno de GCP o AWS, incluidas las reglas `google_compute_firewall` y los recursos `aws_security_group`.
`gcp_outputs.tf`, `aws_outputs.tf`	Define las variables que se muestran cuando se completa la implementación, por ejemplo, la `external_ip` y la `internal_ip` de la instancia de VM implementada.
`terraform.tfstate`	[SALIDA]. Especifica el archivo que usa Terraform para almacenar el estado del recurso del cliente después de verificar con la nube. Para obtener más detalles, consulta Administra proyectos de GCP con Terraform.
`run_graph.sh`	Secuencia de comandos de Shell para generar un archivo PNG desde Terraform que muestre las dependencias de recursos. Puedes ver el resultado de esta secuencia de comandos en images/gcpawsvpn_plan_graph.png.

En este instructivo, se usan secuencias de comandos a fin de crear el archivo terraform.tfvars, que incluye la configuración específica del usuario para credentials y gcp_project_id.

Implementa redes de VPC, instancias de VM, puertas de enlace de VPN y túneles IPsec

Crear conexiones entre varias nubes es complejo. Puedes implementar muchos recursos en paralelo en ambos entornos, pero cuando compilas túneles IPsec, necesitas ordenar las interdependencias con cuidado. Por esta razón, establecer una configuración de implementación segura en código es una forma útil de escalar tu conocimiento de implementación. En la siguiente figura, se resumen los pasos necesarios para crear esta configuración de implementación en varios proveedores.

pasos de implementación

Implementa con Terraform

Terraform usa el archivo terraform.tfstate para capturar el estado del recurso. Para ver el estado actual de los recursos en un formato legible, puedes ejecutar terraform show.

Para que Terraform se autentique de forma correcta con los proveedores, primero debes completar el Instructivo de descripción general. En los siguientes pasos, se supone que ya configuraste Terraform.

En Cloud Shell, navega al directorio terraform:
```
pushd terraform
```
Usa el comando validate de Terraform para validar la sintaxis de los archivos de configuración. Esta verificación de validación es más simple que las que se realizan como parte de los comandos plan y apply en los pasos posteriores. El comando validate no se autentica con ningún proveedor.
```
terraform validate
```
Si no ves un mensaje de error, completaste la validación inicial de la sintaxis y semántica básica de tu archivo. Si ves un mensaje de error, significa que la validación falló.
Usa el comando plan de Terraform para revisar la implementación sin crear instancias de los recursos en la nube. El comando plan requiere una autenticación correcta con todos los proveedores especificados en la configuración.
```
terraform plan
```
Mediante el comando plan, se muestra una lista de salida de recursos que se deben agregar, quitar o actualizar. En la última línea de la salida de plan, se muestra un recuento de los recursos que se deben agregar, cambiar o destruir.
```
Refreshing Terraform state in-memory prior to plan...
...
Plan: 34 to add, 0 to change, 0 to destroy.
```
De forma opcional, visualiza las dependencias de los recursos mediante el comando graph de Terraform. El gráfico de dependencia te ayuda a analizar los recursos implementados. Puedes ver una versión preparada con anterioridad del archivo de salida en images/gcpawsvpn_plan_graph.png..

Mediante la secuencia de comandos run_graph.sh, se crea el archivo PNG ./gcpawsvpn_plan_graph.png, que es similar al que se muestra a continuación:

La secuencia de comandos run_graph.sh se basa en el paquete graphviz. Si graphviz no está instalado, verás un mensaje dot: command not found. En Cloud Shell, puedes instalar graphviz mediante el siguiente comando:
```
sudo apt-get install graphviz
```
Usa el comando apply de Terraform para crear una implementación:
```
terraform apply
```
Mediante el comando apply, se crea una implementación con recursos de respaldo en la nube. En alrededor de cuatro minutos, apply crea más de 30 recursos, incluidas las redes de VPC, las instancias de VM, las puertas de enlace de VPN y los túneles IPsec de GCP y AWS. En la salida del comando apply, se incluyen detalles de los recursos implementados y las variables de salida definidas mediante la configuración.
```
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
```
Si necesitas actualizar el estado final esperado de la configuración, edita los archivos .tf. Para agregar el puerto 23 a la regla google_compute_firewall gcp_allow-ssh, edita gcp_security.tf:
```
ports = ["22", "23"]
```
Terraform analiza las ediciones y, luego, identifica los cambios mínimos necesarios a fin de actualizar el estado de tu implementación para que coincida.
```
terraform apply
```
Terraform modifica gcp-network-gcp-allow-ssh en la configuración actualizada.
Las implementaciones pueden emitir variables de salida para ayudar al flujo de trabajo. En este instructivo, los archivos gcp_outputs.tf y aws_outputs.tf identifican las direcciones IP internas y externas asignadas de las instancias de VM como variables de salida. Estas direcciones se imprimen de forma automática cuando se completa el paso apply. Si más adelante quieres volver a mostrar los valores de las variables de salida en el flujo de trabajo, usa el comando output.
```
terraform output
```
En las variables de salida que se definen en esta configuración, se incluyen las direcciones IP internas y externas de las instancias de VM. Si quieres usar el comando de ssh para la validación de red, necesitas que las direcciones IP externas se conecten a las instancias 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
```
Usa el comando show de Terraform para inspeccionar los recursos implementados y verificar el estado actual.
```
terraform show
```
Resultado:
```
...
google_compute_instance.gcp-vm:
...
Outputs:
...
```

Para revisar tus instancias, usa gcloud compute instances list: o usa Cloud Console, en el panel Instancias de 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

Si deseas verificar que la instancia de VM de GCP esté en funcionamiento, usa el comando ssh para conectarte a ella:
```
ssh -i ~/.ssh/vm-ssh-key [GCP_EXTERNAL_IP]
```
Ejecuta los comandos ping y curl en tu sesión de ssh:
```
ping -c 5 google.com
curl ifconfig.co/ip
```
Ejecuta controles de rendimiento de red simples desde la instancia de VM de GCP. Usa secuencias de comandos preinstaladas para ejecutar una prueba en la interfaz interna y externa de cada red.
1. Sobre IP externas:
```
/tmp/run_iperf_to_ext.sh
```
  La secuencia de comandos ejecuta una prueba de rendimiento de 30 segundos que produce datos de resumen sobre el rendimiento de la red.
  
  Resultado:
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
2. Sobre VPN (IP internas):
```
/tmp/run_iperf_to_int.sh
```
  La secuencia de comandos ejecuta una prueba de rendimiento de 30 segundos que produce datos de resumen sobre el rendimiento de la red.
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
Cuando completes las revisiones de la instancia de VM de GCP, ingresa el siguiente comando:
```
exit
```
Si deseas verificar que la instancia de VM de AWS esté en funcionamiento, usa el comando ssh para conectarte a ella:
```
ssh -i ~/.ssh/vm-ssh-key ubuntu@[AWS_EXTERNAL_IP]
```
Ejecuta los comandos ping y curl en tu sesión de ssh:
```
ping -c 5 google.com
curl ifconfig.co/ip
```
Ejecuta controles de rendimiento de red simples desde la instancia de VM de GCP. Usa secuencias de comandos preinstaladas para ejecutar una prueba en la interfaz interna y externa de cada red.
1. Sobre IP externas:
```
/tmp/run_iperf_to_ext.sh
```
  La secuencia de comandos ejecuta una prueba de rendimiento de 30 segundos que produce datos de resumen sobre el rendimiento de la red.
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
2. Sobre VPN (IP internas):
```
/tmp/run_iperf_to_int.sh
```
  La secuencia de comandos ejecuta una prueba de rendimiento de 30 segundos que produce datos de resumen sobre el rendimiento de la red.
```
...
[SUM]   ... sender
[SUM]   ... receiver
...
```
Cuando completes las revisiones de la instancia de VM de AWS, ingresa el siguiente comando:
```
exit
```

Implementaste una conexión segura y privada de sitio a sitio entre GCP y AWS de forma correcta mediante VPN.

Realiza una limpieza

Limpia los recursos implementados. Se te seguirá cobrando por las instancias de VM hasta que ejecutes el comando de implementación destroy.

Ejecuta el comando plan -destroy opcional para revisar los recursos afectados por destroy:

terraform plan -destroy

Resultado:

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

Debido a que, mediante el comando destroy, se borrarán los recursos de forma permanente, ingresa yes para confirmar tus intenciones. Por lo general, el comando destroy se completa en alrededor 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
```
Ingresa yes para confirmar la destrucción del recurso que creaste.
```
Destroy complete! Resources: 34 destroyed.
```
Ejecuta el comando show para mostrar el estado de los recursos:
```
terraform show
```
Como destruiste todos los recursos, el comando show no muestra líneas, lo que indica que ya no hay recursos implementados.
Por último, restablece el directorio:
```
popd > /dev/null
```

Completaste con éxito la implementación y la limpieza de una conexión segura y privada de sitio a sitio entre instancias en GCP y AWS.

¿Qué sigue?

A fin de obtener información sobre un método más avanzado para almacenar el archivo de estado de Terraform en Cloud Storage, consulta Administra proyectos de GCP con Terraform.
Para obtener más información sobre Open Cloud, consulta ¿Y si pudieses ejecutar lo mismo en todas partes? (Cómo escapar del compromiso con una pila de múltiples nubes).
Para obtener más información sobre Open Cloud y las opciones de configuración híbridas, mira Day 3 Keynote (Discurso de apertura del día 3) (con Vint Cerf y Sam Ramji) en Google Cloud Next de marzo de 2017.
Para revisar los detalles sobre Cloud VPN, consulta la siguiente documentación:
Prueba otras funciones de Google Cloud. Consulta nuestros instructivos.