Esta página foi traduzida pela API Cloud Translation.

Executar aplicativos do App Engine no GKE

Neste guia, você verá como executar um aplicativo do ambiente flexível do App Engine no GKE. Para executar o app no GKE, é necessário criar um Dockerfile para ele, criar um contêiner com o Cloud Build e, em seguida, executar esse contêiner no GKE. Não é necessário alterar o código.

Antes de começar

Antes de seguir as instruções desta página, realize as etapas abaixo:

Verifique se o aplicativo foi implantado e executado com êxito no ambiente flexível do App Engine.
Nestas instruções, você usará o mesmo projeto usado no aplicativo do App Engine. Sempre será possível criar e usar um novo projeto, se você quiser.
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
Faça o download da Google Cloud CLI e instale-a. Depois, inicialize a ferramenta gcloud: Fazer o download do SDK do Google Cloud.

Se preferir, use o Cloud Shell, que vem com a CLI gcloud, git e outros recursos pré-instalados. como compatibilidade com idiomas, ferramentas e editores.
Instale a ferramenta de linha de comando kubectl:
```
gcloud components install kubectl
```
Fazer o download e instalar o git.

Como criar um Dockerfile para um aplicativo do App Engine

Crie um Dockerfile para o app, conforme descrito em Criar um Dockerfile.

Como criar um contêiner do Dockerfile

Para criar um contêiner, siga as instruções abaixo:

Verifique se você está no diretório do aplicativo do App Engine que contém o Dockerfile.
Altere o projeto padrão usado pela ferramenta gcloud para que aponte para o projeto que você está usando para executar o aplicativo no GKE:
```
gcloud config set project [YOUR-PROJECT-ID]
```
Substitua [YOUR-PROJECT-ID] pelo ID do projeto do GKE.
Crie o contêiner usando o comando a seguir:
```
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 contêiner que você quer usar para o contêiner do aplicativo.

Aguarde até que o contêiner seja criado. Isso pode demorar algum tempo. Se o contêiner for criado com êxito, será exibida uma mensagem semelhante a 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<

Observe o nome do contêiner: você precisa especificá-lo ao executar o contêiner no GKE.

Como executar seu aplicativo no GKE

Para executar o contêiner que contém seu aplicativo, siga estas etapas:

Crie o cluster (isso pode levar alguns minutos):
```
gcloud container clusters create [YOUR-CLUSTER-NAME]
```
Substitua [YOUR-CLUSTER-NAME] pelo nome que você quer fornecer ao cluster.
Na linha de comando, defina sua zona de computação:
```
gcloud config set compute/zone us-central1-b
```
Verifique se a ferramenta kubectl do GKE está autorizada:
```
gcloud container clusters get-credentials [YOUR-CLUSTER-NAME]
```
Siga as instruções para autorizar a ferramenta.
Execute o contêiner que contém seu app:
```
kubectl create deployment [YOUR-DEPLOYMENT-NAME] --image=gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME]
```
Substitua [YOUR-DEPLOYMENT-NAME] pelo nome que você quer usar para a implantação, [YOUR-PROJECT-ID] pelo ID do projeto do GKE e [YOUR-CONTAINER-NAME] pelo nome do contêiner criado para seu aplicativo.
Exponha o contêiner a acesso público:
```
kubectl expose deployment [YOUR-DEPLOYMENT-NAME] --type="LoadBalancer" --port=8080
```
Substitua [YOUR-DEPLOYMENT-NAME] pelo nome que você usou nas etapas anteriores. Talvez seja necessário aguardar alguns minutos para que o IP externo fique visível.

Observação: a opção type="LoadBalancer" em kubectl solicita ao Google Cloud Platform um balanceador de carga para seu contêiner, que é faturado de acordo com o sistema de preços normal do balanceador de carga.
Veja o endereço IP externo do aplicativo:
```
kubectl get service [YOUR-DEPLOYMENT-NAME]
```
Substitua [YOUR-DEPLOYMENT-NAME] pelo nome que você usou nas etapas anteriores. Se o campo EXTERNAL IP estiver vazio, espere um pouco. Depois, chame novamente o comando.
Veja o aplicativo em execução no GKE:
```
http://EXTERNAL-IP:8080
```
Substitua EXTERNAL-IP pelo endereço IP externo que você recebeu na etapa anterior.

Parabéns! Você implantou e executou o aplicativo PHP do App Engine no GKE com êxito.

A seguir

É recomendável saber mais sobre o Kubernetes e o comando kubectl. O Google Kubernetes Engine usa o Kubernetes para gerenciar, implantar e escalar contêineres. Há mais informações sobre o Kubernetes no site externo do Kubernetes (em inglês).

Neste guia, usamos kubectl, a interface de linha de comando para gerenciar clusters do Kubernetes. Mais informações sobre a kubectl estão disponíveis na referência do kubectl (em inglês).