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.
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).