Ejecuta apps de App Engine en GKE

En esta guía, se muestra cómo ejecutar una app del entorno flexible de App Engine en GKE. Para ejecutar tu app en GKE, debes crear un Dockerfile y compilar un contenedor con Cloud Build y, luego, ejecutar ese contenedor en GKE. No se requieren cambios de códigos.

Antes de comenzar

Antes de seguir las instrucciones de esta página, haz lo siguiente:

Comprueba que tu aplicación se implemente y ejecute con éxito en el entorno flexible de App Engine.
En estas instrucciones, usarás el mismo proyecto que usaste para tu app de App Engine. Si lo deseas, puedes crear y usar un proyecto nuevo en cualquier momento.
Enable the GKE, Cloud Build APIs.
Enable the APIs
Descarga y, luego, instala Google Cloud CLI. Luego, inicializa la herramienta de gcloud: Descarga el SDK de Google Cloud.

Otra opción es usar Cloud Shell, que incluye gcloud CLI, git y otras funciones preinstaladas. como herramientas de lenguajes, herramientas y editores.
Instala la herramienta de línea de comandos kubectl:
```
gcloud components install kubectl
```
Descarga y luego instala git.

Crea un Dockerfile para tu app de App Engine

Compila un Dockerfile para tu app como se describe en la sección sobre cómo crear un Dockerfile.

Compila un contenedor desde el Dockerfile

Para compilar un contenedor, haz lo siguiente:

Asegúrate de estar en el directorio de la aplicación de App Engine que contiene el Dockerfile.
Cambia el proyecto predeterminado que usa la herramienta gcloud para que apunte al proyecto que estás usando para ejecutar tu app en GKE:
```
gcloud config set project [YOUR-PROJECT-ID]
```
Reemplaza [YOUR-PROJECT-ID] por tu ID del proyecto de GKE.
Compila el contenedor con el siguiente comando:
```
gcloud builds submit --tag gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME] .
```
Reemplaza [YOUR-PROJECT-ID] por el ID del proyecto de tu proyecto de GKE y reemplaza [YOUR-CONTAINER-NAME] por el nombre del contenedor que deseas usar para tu contenedor de apps.

Espera a que el contenedor se compile: puede tardar un poco. Cuando el proceso termina con éxito, muestra un mensaje como este:

Created [https://cloudbuild.googleapis.com/v1/projects/YOUR-PROJECT-ID/builds/xxxxxxx-xxxx-xxx-xxx-xxxxxxxxxxxx].
Logs are permanently available at [https://console.developers.google.com/logs/viewer?resource=build&project=YOUR-PROJECT-ID&filters=text:xxxx-xxx-xxx-xxxxxxxxxxxx]].

ID  CREATE_TIME DURATION  SOURCE                                                     IMAGES                               STATUS
xxxxxxx-xxxx-xxx-xxx-xxxxxxxxxxxx  2017-03-04T00:42:10+00:00  1M32S     gs://YOUR-PROJECT-ID_cloudbuild/source/xxxxxxx.08.tgz  gcr.io/YOUR-PROJECT-ID/YOUR-CONTAINER-NAME  SUCCESS<

Recuerda el nombre del contenedor: deberás especificarlo cuando lo ejecutes en GKE.

Ejecuta tu aplicación en GKE

Para ejecutar el contenedor que contiene tu aplicación, haz lo siguiente:

Crea el clúster (esto puede tardar unos minutos):
```
gcloud container clusters create [YOUR-CLUSTER-NAME]
```
Reemplaza [YOUR-CLUSTER-NAME] por el nombre que deseas darle al clúster.
Desde la línea de comandos, establece tu zona de procesamiento:
```
gcloud config set compute/zone us-central1-b
```
Asegúrate de que la herramienta kubectl de GKE esté autorizada:
```
gcloud container clusters get-credentials [YOUR-CLUSTER-NAME]
```
Sigue las indicaciones para autorizar la herramienta.
Ejecuta el contenedor que contiene tu aplicación:
```
kubectl create deployment [YOUR-DEPLOYMENT-NAME] --image=gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME]
```
Reemplaza [YOUR-DEPLOYMENT-NAME] por el nombre que deseas usar para tu implementación, reemplaza [YOUR-PROJECT-ID] por tu ID del proyecto de GKE y reemplaza [YOUR-CONTAINER-NAME] por el nombre del contenedor que creaste para tu app.
Haz que el contenedor sea de acceso público:
```
kubectl expose deployment [YOUR-DEPLOYMENT-NAME] --type="LoadBalancer" --port=8080
```
Reemplaza [YOUR-DEPLOYMENT-NAME] por el nombre que usaste en los pasos anteriores. Es posible que debas esperar varios minutos para poder ver la IP externa.
Nota: La opción type=“LoadBalancer” en kubectl solicita que Google Cloud Platform aprovisione un balanceador de cargas para tu contenedor, que se factura según el precio regular del balanceador de cargas.
Obtén la dirección IP externa de tu app:
```
kubectl get service [YOUR-DEPLOYMENT-NAME]
```
Reemplaza [YOUR-DEPLOYMENT-NAME] por el nombre que usaste en los pasos anteriores. Si el campo EXTERNAL IP está vacío, espera un momento y, a continuación, vuelve a invocar el comando.
Verifica que la aplicación se ejecuta en GKE:
```
http://EXTERNAL-IP:8080
```
Reemplaza EXTERNAL-IP por la dirección IP externa que obtuviste en el paso anterior.

Implementaste y ejecutaste con éxito tu aplicación de App Engine en GKE.

¿Qué sigue?

Se recomienda obtener más información sobre Kubernetes y el comando kubectl. Google Kubernetes Engine usa Kubernetes para la administración, la implementación y el escalamiento de contenedores. Hay más información disponible sobre Kubernetes en el sitio de Kubernetes externo.

En esta guía, se usa kubectl, la interfaz de línea de comandos para administrar los clústeres de Kubernetes. Puedes encontrar más información sobre kubectl en la referencia de kubectl.