Esegui le app di App Engine su GKE

Questa guida mostra come eseguire un'app dell'ambiente flessibile di App Engine su GKE. Per eseguire la tua app su GKE, devi creare un Dockerfile per l'app, creare un container con Cloud Build ed eseguire il container in GKE. senza dover apportare modifiche al codice.

Prima di iniziare

Prima di seguire le istruzioni riportate in questa pagina, procedi nel seguente modo:

Verifica che il deployment dell'app e la sua esecuzione avvengano correttamente nell'ambiente flessibile di App Engine.
In queste istruzioni, utilizzerai lo stesso progetto che hai utilizzato per l'app App Engine. Puoi sempre creare e utilizzare un nuovo progetto, se vuoi.
Abilita le API GKE, Cloud Build.
Abilita le API
Scarica e installa Google Cloud CLI, quindi inizializza lo strumento gcloud: Scarica Google Cloud SDK.

In alternativa, puoi utilizzare Cloud Shell, che viene fornito con gcloud CLI, git e altre funzionalità preinstallate, come il supporto per la lingua, gli strumenti e gli editor.
Installa lo strumento a riga di comando kubectl:
```
gcloud components install kubectl
```
Scarica e installa git.

Creazione di un Dockerfile per l'app App Engine

Crea un Dockerfile per la tua app come descritto in Creare un Dockerfile.

Creazione di un container da Dockerfile

Per creare un container:

Assicurati di trovarti nella directory dell'app App Engine che contiene il Dockerfile.
Modifica il progetto predefinito utilizzato dallo strumento gcloud in modo che rimandi al progetto che stai utilizzando per eseguire l'app in GKE:
```
gcloud config set project [YOUR-PROJECT-ID]
```
Sostituisci [YOUR-PROJECT-ID] con l'ID del tuo progetto GKE.
Crea il container utilizzando il seguente comando:
```
gcloud builds submit --tag gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME] .
```
Sostituisci [YOUR-PROJECT-ID] con l'ID del tuo progetto GKE e [YOUR-CONTAINER-NAME] con il nome del container che vuoi utilizzare per il container dell'app.

Attendi la creazione del container: potrebbe richiedere un po' di tempo. Al termine, viene visualizzato un messaggio simile al seguente:

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<

Prendi nota del nome del container: devi specificarlo quando lo esegui in GKE.

Esecuzione dell'app in GKE

Per eseguire il contenitore che contiene la tua app:

Crea il cluster (l'operazione potrebbe richiedere alcuni minuti):
```
gcloud container clusters create [YOUR-CLUSTER-NAME]
```
Sostituisci [YOUR-CLUSTER-NAME] con il nome che vuoi assegnare al cluster.
Dalla riga di comando, imposta la zona di computing:
```
gcloud config set compute/zone us-central1-b
```
Assicurati che lo strumento kubectl di GKE sia autorizzato:
```
gcloud container clusters get-credentials [YOUR-CLUSTER-NAME]
```
Segui le istruzioni per autorizzare lo strumento.
Esegui il contenitore che contiene la tua app:
```
kubectl create deployment [YOUR-DEPLOYMENT-NAME] --image=gcr.io/[YOUR-PROJECT-ID]/[YOUR-CONTAINER-NAME]
```
Sostituisci [YOUR-DEPLOYMENT-NAME] con il nome che vuoi utilizzare per il deployment, [YOUR-PROJECT-ID] con l'ID del tuo progetto GKE e [YOUR-CONTAINER-NAME] con il nome del container che hai creato per la tua app.
Esponi il container per l'accesso pubblico:
```
kubectl expose deployment [YOUR-DEPLOYMENT-NAME] --type="LoadBalancer" --port=8080
```
Sostituisci [YOUR-DEPLOYMENT-NAME] con il nome che hai utilizzato nei passaggi precedenti. Potrebbe essere necessario attendere alcuni minuti prima che l'IP esterno sia visibile.

Nota: l'opzione type="LoadBalancer" in kubectl richiede a Google piattaforma Cloud il provisioning di un bilanciatore del carico per il tuo container, che viene fatturato in base al normale prezzo del bilanciatore del carico.
Visualizza l'indirizzo IP esterno della tua app:
```
kubectl get service [YOUR-DEPLOYMENT-NAME]
```
Sostituisci [YOUR-DEPLOYMENT-NAME] con il nome che hai utilizzato nei passaggi precedenti. Se il campo EXTERNAL IP è vuoto, attendi un po' di tempo, quindi richiama nuovamente il comando.
Visualizza l'app in esecuzione in GKE:
```
http://EXTERNAL-IP:8080
```
Sostituisci EXTERNAL-IP con l'indirizzo IP esterno che hai ottenuto nel passaggio precedente.

Hai eseguito il deployment dell'app App Engine su GKE ed eseguirlo.

Passaggi successivi

Scopri di più su Kubernetes e sul comando kubectl. Google Kubernetes Engine utilizza Kubernetes per la gestione, il deployment e la scalabilità dei container. Ulteriori informazioni su Kubernetes sono disponibili sul sito esterno di Kubernetes.

Questa guida utilizza kubectl, l'interfaccia a riga di comando per la gestione dei cluster Kubernetes. Ulteriori informazioni su kubectl sono disponibili nel riferimento kubectl.