Guida rapida: deployment di un'app in un cluster GKE

Eseguire il deployment di un'app in un cluster GKE

In questa guida rapida, esegui il deployment di una semplice applicazione containerizzata del server web in un cluster Google Kubernetes Engine (GKE). Imparerai a creare un cluster e a eseguire il deployment dell'applicazione nel cluster in modo che gli utenti possano accedervi.

Questa guida rapida presuppone che tu abbia una conoscenza di base di Kubernetes.

Prima di iniziare

Per abilitare l'API Kubernetes Engine:
  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API Artifact Registry and Google Kubernetes Engine.

    Abilita le API

  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Abilita le API Artifact Registry and Google Kubernetes Engine.

    Abilita le API

Assicurati di avere la quota disponibile per:

  • 1 CPU di Compute Engine nell'area geografica del tuo cluster.
  • 1 indirizzo IP in uso.

Per verificare la tua quota disponibile, utilizza Cloud Console.

Avvia Cloud Shell

In questo tutorial utilizzerai Cloud Shell, un ambiente shell per la gestione delle risorse ospitate su Google Cloud.

Cloud Shell include l'interfaccia a riga di comando di Google Cloud e lo strumento a riga di comando kubectl. L'interfaccia a riga di comando gcloud fornisce l'interfaccia a riga di comando principale per Google Cloud, mentre kubectl fornisce l'interfaccia a riga di comando principale per l'esecuzione dei comandi nei cluster Kubernetes.

Avvia Cloud Shell:

  1. Vai a Google Cloud Console.

    Google Cloud console

  2. Nell'angolo in alto a destra della console, fai clic sul pulsante Attiva Cloud Shell:

Una sessione di Cloud Shell si apre all'interno di un frame inferiore nella console. Puoi utilizzare questa shell per eseguire i comandi gcloud e kubectl.

Configura le impostazioni predefinite per l'interfaccia a riga di comando gcloud

Utilizza l'interfaccia a riga di comando gcloud per configurare le seguenti impostazioni predefinite: progetto, zona di calcolo e area geografica di Compute.

Il progetto ha un ID progetto, che è il suo identificatore univoco. Quando crei un progetto, puoi utilizzare l'ID progetto generato automaticamente o crearne uno personalizzato.

Una zona di Compute Engine è una località nell'area geografica in cui risiedono i cluster e le relative risorse. Ad esempio, us-west1-a è una zona nell'area geografica us-west. L'area geografica di Compute è l'area geografica in cui si trovano i cluster e le relative risorse (ad esempio us-west).

La configurazione di queste impostazioni predefinite semplifica l'esecuzione dei comandi gcloud, poiché gcloud richiede di specificare il progetto e la località in cui lavorare. Puoi anche specificare queste impostazioni o ignorarle per impostazione predefinita tramite flag, ad esempio --project, --zone, --region e --cluster, nei tuoi comandi gcloud.

Quando crei le risorse GKE dopo aver configurato il progetto, la zona e l'area geografica predefiniti, le risorse vengono create automaticamente nel progetto, nella zona e nell'area geografica predefiniti.

In Cloud Shell, esegui questi passaggi:

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID
    

    Sostituisci PROJECT_ID con l'ID progetto.

  2. Imposta la zona predefinita:

    gcloud config set compute/zone COMPUTE_ZONE
    

    Sostituisci COMPUTE_ZONE con la tua zona di calcolo, ad esempio us-west1-a.

  3. Imposta l'area geografica predefinita:

    gcloud config set compute/region COMPUTE_REGION
    

    Sostituisci COMPUTE_REGION con l'area geografica Compute, ad esempio us-west1.

Crea un cluster GKE

Un cluster è costituito da almeno una macchina del piano di controllo del cluster e da più macchine worker denominate nodi. I nodi sono istanze di macchine virtuali (VM) Compute Engine che eseguono i processi Kubernetes necessari per renderle parte del cluster. Esegui il deployment delle applicazioni nei cluster e le applicazioni vengono eseguite sui nodi.

Per creare cluster in GKE, devi scegliere una modalità operativa: Autopilot o Standard. Se utilizzi la modalità Autopilot, il cluster è a livello di area geografica per impostazione predefinita. Se utilizzi la modalità standard, questo tutorial crea un cluster di zona.

Autopilot

Crea un cluster Autopilot denominato hello-cluster:

gcloud container clusters create-auto hello-cluster

Standard

Crea un cluster standard di un nodo denominato hello-cluster:

gcloud container clusters create hello-cluster --num-nodes=1

Il processo di creazione del cluster potrebbe richiedere alcuni minuti.

Recupera le credenziali di autenticazione per il cluster

Dopo aver creato il cluster, è necessario recuperare le credenziali di autenticazione per interagire con il cluster:

gcloud container clusters get-credentials hello-cluster

Questo comando configura kubectl in modo che utilizzi il cluster che hai creato.

Eseguire il deployment di un'applicazione nel cluster

Ora che hai creato un cluster, puoi eseguirvi il deployment di un'applicazione containerizzata. Per questa guida rapida, puoi eseguire il deployment della nostra applicazione web di esempio hello-app.

GKE usa gli oggetti Kubernetes per creare e gestire le risorse del cluster. Kubernetes fornisce l'oggetto Deployment per eseguire il deployment di applicazioni stateless come i server web. Gli oggetti Service definiscono le regole e il bilanciamento del carico per l'accesso all'applicazione da Internet.

Crea il deployment

Per eseguire hello-app nel cluster, devi eseguire il deployment dell'applicazione eseguendo questo comando:

kubectl create deployment hello-server \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Questo comando di Kubernetes, kubectl create deployment, crea un deployment denominato hello-server. Il pod di Deployment esegue l'immagine container hello-app.

In questo comando:

  • --image specifica un'immagine container di cui eseguire il deployment. In questo caso, il comando esegue il pull dell'immagine di esempio da un repository Artifact Registry, us-docker.pkg.dev/google-samples/containers/gke/hello-app. :1.0 indica la versione specifica dell'immagine di cui va eseguito il pull. Se non specifichi una versione, viene utilizzata l'immagine con il tag predefinito latest.

Esponi il deployment

Dopo aver eseguito il deployment dell'applicazione, devi esporla a Internet in modo che gli utenti possano accedervi. Per esporre l'applicazione puoi creare un Service, una risorsa Kubernetes che espone l'applicazione a traffico esterno.

Per esporre l'applicazione, esegui questo comando kubectl expose:

kubectl expose deployment hello-server --type LoadBalancer --port 80 --target-port 8080

Il trasferimento del flag --type LoadBalancer crea un bilanciatore del carico Compute Engine per il container. Il flag --port inizializza la porta pubblica 80 a Internet e il flag --target-port instrada il traffico alla porta 8080 dell'applicazione.

I bilanciatori del carico vengono fatturati in base ai prezzi del bilanciatore del carico di Compute Engine.

Ispeziona e visualizza l'applicazione

  1. Controlla i pod in esecuzione utilizzando kubectl get pods:

    kubectl get pods
    

    Dovresti visualizzare un pod hello-server in esecuzione sul tuo cluster.

  2. Controlla il Servizio hello-server utilizzando kubectl get service:

    kubectl get service hello-server
    

    Dall'output di questo comando copia l'indirizzo IP esterno del Service dalla colonna EXTERNAL-IP.

  3. Visualizza l'applicazione dal browser web utilizzando l'indirizzo IP esterno con la porta esposta:

    http://EXTERNAL_IP
    

Hai appena eseguito il deployment di un'applicazione web containerizzata in GKE.

esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

  1. Elimina il servizio dell'applicazione eseguendo kubectl delete:

    kubectl delete service hello-server
    

    Questo comando elimina il bilanciatore del carico di Compute Engine che hai creato quando hai esposto il deployment.

  2. Elimina il cluster in esecuzione gcloud container clusters delete:

    gcloud container clusters delete hello-cluster
    

Facoltativo: revisione del codice hello-app

hello-app è un'applicazione server web semplice composta da due file: main.go e Dockerfile.

hello-app è inserito in un'immagine container Docker. Le immagini container vengono archiviate in qualsiasi registro di immagini Docker, ad esempio Artifact Registry. Hosting in hello-app in un repository Artifact Registry in us-docker.pkg.dev/google-samples/containers/gke/hello-app.

main.go

main.go è un'implementazione del server web scritta nel linguaggio di programmazione Go. Il server risponde a qualsiasi richiesta HTTP con un messaggio "Hello, world!".

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Dockerfile

Dockerfile descrive l'immagine che vuoi creare con Docker, incluse tutte le risorse e le dipendenze, e specifica la porta di rete che deve essere esposta dall'app. Per ulteriori informazioni su come funziona questo file, consulta la sezione Riferimento Dockerfile nella documentazione Docker.

FROM golang:1.8-alpine
ADD . /go/src/hello-app
RUN go install hello-app

FROM alpine:latest
COPY --from=0 /go/bin/hello-app .
ENV PORT 8080
CMD ["./hello-app"]

Passaggi successivi

Provalo

Se non hai mai utilizzato Google Cloud, crea un account per valutare le prestazioni di GKE in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova GKE gratuitamente