Esta página se ha traducido con Cloud Translation API.

Ejecutar aplicaciones de App Engine en GKE

En esta guía se explica cómo ejecutar una aplicación del entorno flexible de App Engine en GKE. Para ejecutar tu aplicación en GKE, debes crear un Dockerfile, compilar un contenedor con Cloud Build y, a continuación, ejecutar ese contenedor en GKE. No es necesario hacer ningún cambio en el código.

Antes de empezar

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

Verifica que tu aplicación se despliega y se ejecuta correctamente en el entorno flexible de App Engine.
En estas instrucciones, usarás el mismo proyecto que usaste para tu aplicación de App Engine. Si quieres, puedes crear y usar un proyecto nuevo.
Enable the GKE, Cloud Build APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs
Descarga e instala la CLI de Google Cloud y, a continuación, inicializa la herramienta gcloud: Descarga el SDK de Google Cloud.

También puedes usar Cloud Shell, que incluye la CLI de gcloud, git y otras funciones preinstaladas, como compatibilidad con idiomas, herramientas y editores.
Instala la herramienta de línea de comandos kubectl:
```
gcloud components install kubectl
```
Descarga e instala git.

Crear un Dockerfile para una aplicación de App Engine

Crea un Dockerfile para tu aplicación tal como se describe en Crear un Dockerfile.

Crear un contenedor a partir del Dockerfile

Para crear un contenedor, sigue estos pasos:

Asegúrate de que te encuentras en el directorio de la aplicación de App Engine que contiene el archivo Dockerfile.
Cambia el proyecto predeterminado que usa la herramienta gcloud para que apunte al proyecto que usas para ejecutar tu aplicación en GKE:
```
gcloud config set project [YOUR-PROJECT-ID]
```
Sustituye [YOUR-PROJECT-ID] por el ID de tu proyecto de GKE.
Compila el contenedor con el siguiente comando:
```
gcloud builds submit --tag gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME] .
```
Sustituye [YOUR-PROJECT-ID] por el ID del proyecto de GKE y [YOUR-CONTAINER-NAME] por el nombre del contenedor que quieras usar para el contenedor de tu aplicación.

Espera a que se compile el contenedor. Puede tardar un poco. Cuando se complete correctamente, se mostrará 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<

Anota el nombre del contenedor, ya que tendrás que especificarlo cuando lo ejecutes en GKE.

Ejecutar la aplicación en GKE

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

Crea el clúster (este proceso puede tardar unos minutos):
```
gcloud container clusters create [YOUR-CLUSTER-NAME]
```
Sustituye [YOUR-CLUSTER-NAME] por el nombre que quieras asignar al clúster.
Desde la línea de comandos, define tu zona de cálculo:
```
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]
```
Sustituye [YOUR-DEPLOYMENT-NAME] por el nombre que quieras usar para tu implementación, [YOUR-PROJECT-ID] por el ID de tu proyecto de GKE y [YOUR-CONTAINER-NAME] por el nombre del contenedor que has creado para tu aplicación.
Expón el contenedor para que se pueda acceder públicamente:
```
kubectl expose deployment [YOUR-DEPLOYMENT-NAME] --type="LoadBalancer" --port=8080
```
Sustituye [YOUR-DEPLOYMENT-NAME] por el nombre que has usado en los pasos anteriores. Es posible que tengas que esperar varios minutos para que se muestre la IP externa.

Nota: La opción type="LoadBalancer" en las solicitudes kubectl hace que Google Cloud Platform aprovisione un balanceador de carga para tu contenedor, que se factura según los precios habituales de los balanceadores de carga.
Para ver la dirección IP externa de tu aplicación, sigue estos pasos:
```
kubectl get service [YOUR-DEPLOYMENT-NAME]
```
Sustituye [YOUR-DEPLOYMENT-NAME] por el nombre que has usado en los pasos anteriores. Si el campo EXTERNAL IP está vacío, espera un rato y vuelve a invocar el comando.
Ver la aplicación en ejecución en GKE:
```
http://EXTERNAL-IP:8080
```
Sustituye EXTERNAL-IP por la dirección IP externa que has obtenido en el paso anterior.

Has desplegado y ejecutado correctamente tu aplicación de App Engine en GKE.

Siguientes pasos

Te recomendamos que consultes más información sobre Kubernetes y el comando kubectl. Google Kubernetes Engine usa Kubernetes para gestionar, desplegar y escalar contenedores. Puedes consultar más información sobre Kubernetes en el sitio externo de Kubernetes.

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