Esta página foi traduzida pela API Cloud Translation.

Execute apps do App Engine no GKE

Este guia mostra como executar uma app do ambiente flexível do App Engine no GKE. Para executar a sua app no GKE, tem de criar um Dockerfile para a mesma, criar um contentor com o Cloud Build e, em seguida, executar esse contentor no GKE. Não são necessárias alterações ao código.

Antes de começar

Antes de seguir as instruções nesta página, siga estes passos:

Verifique se a sua app é implementada e executada com êxito no ambiente flexível do App Engine.
Nestas instruções, vai usar o mesmo projeto que usou para a sua app do App Engine. Se quiser, pode sempre criar e usar um novo projeto.
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
Descarregue e instale a CLI Google Cloud e, em seguida, inicialize a ferramenta gcloud: Descarregue o SDK do Google Cloud.

Em alternativa, pode usar o Cloud Shell, que inclui a CLI gcloud, git e outras funcionalidades pré-instaladas, como suporte de idiomas, ferramentas e editores.
Instale a ferramenta de linha de comandos kubectl:
```
gcloud components install kubectl
```
Transfira e instale o git.

Criar um Dockerfile para a sua app do App Engine

Crie um Dockerfile para a sua app, conforme descrito no artigo Crie um Dockerfile.

Criar um contentor a partir do Dockerfile

Para criar um contentor:

Certifique-se de que está no diretório da app do App Engine que contém o Dockerfile.
Altere o projeto predefinido usado pela ferramenta gcloud para que aponte para o projeto que está a usar para executar a sua app no GKE:
```
gcloud config set project [YOUR-PROJECT-ID]
```
Substitua [YOUR-PROJECT-ID] pelo ID do projeto do GKE.
Crie o contentor com o seguinte comando:
```
gcloud builds submit --tag gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME] .
```
Substitua [YOUR-PROJECT-ID] pelo ID do projeto do GKE e substitua [YOUR-CONTAINER-NAME] pelo nome do contentor que quer usar para o contentor da app.

Aguarde a criação do contentor. Pode demorar algum tempo. Quando termina com êxito, é apresentada uma mensagem como esta:

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<

Tome nota do nome do contentor: tem de o especificar quando o executar no GKE.

Executar a sua app no GKE

Para executar o contentor que contém a sua app:

Crie o cluster (este processo pode demorar alguns minutos):
```
gcloud container clusters create [YOUR-CLUSTER-NAME]
```
Substitua [YOUR-CLUSTER-NAME] pelo nome que quer dar ao cluster.
Na linha de comandos, defina a zona de computação:
```
gcloud config set compute/zone us-central1-b
```
Certifique-se de que a ferramenta kubectlGKE está autorizada:
```
gcloud container clusters get-credentials [YOUR-CLUSTER-NAME]
```
Siga as instruções para autorizar a ferramenta.
Execute o contentor que contém a sua app:
```
kubectl create deployment [YOUR-DEPLOYMENT-NAME] --image=gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME]
```
Substitua [YOUR-DEPLOYMENT-NAME] pelo nome que quer usar para a sua implementação, substitua [YOUR-PROJECT-ID] pelo ID do projeto do GKE e substitua [YOUR-CONTAINER-NAME] pelo nome do contentor que criou para a sua app.
Exponha o contentor para acesso público:
```
kubectl expose deployment [YOUR-DEPLOYMENT-NAME] --type="LoadBalancer" --port=8080
```
Substitua [YOUR-DEPLOYMENT-NAME] pelo nome que usou nos passos anteriores. Pode ter de aguardar vários minutos antes de o IP externo ficar visível.

Nota: a opção type="LoadBalancer" nos pedidos kubectl solicita que o Google Cloud Platform aprovisione um balanceador de carga para o seu contentor, que é faturado de acordo com os preços normais do balanceador de carga.
Veja o endereço IP externo da sua app:
```
kubectl get service [YOUR-DEPLOYMENT-NAME]
```
Substitua [YOUR-DEPLOYMENT-NAME] pelo nome que usou nos passos anteriores. Se o campo EXTERNAL IP estiver vazio, aguarde algum tempo e, em seguida, invoque novamente o comando.
Veja a app em execução no GKE:
```
http://EXTERNAL-IP:8080
```
Substitua EXTERNAL-IP pelo endereço IP externo que obteve no passo anterior.

Implementou e executou a sua app do App Engine no GKE com êxito!

O que se segue?

Pode querer saber mais acerca do Kubernetes e do comando kubectl. O Google Kubernetes Engine usa o Kubernetes para a gestão, a implementação e o escalamento de contentores. Estão disponíveis mais informações sobre o Kubernetes no site do Kubernetes externo.

Este guia usa o kubectl, a interface de linhas de comando para gerir clusters do Kubernetes. Estão disponíveis mais informações sobre kubectl na referência do kubectl.