Esegui il deployment di un'app in un cluster GKE

In questa guida rapida, eseguirai il deployment di un'applicazione containerizzata di esempio di un server web in un cluster Google Kubernetes Engine (GKE). Scopri come creare un cluster e come eseguire il deployment dell'applicazione nel cluster in modo che possa essere accessibile agli utenti.

Questa pagina è rivolta a operatori e sviluppatori che eseguono il provisioning e la configurazione delle risorse cloud e il deployment di app e servizi. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli e attività comuni degli utenti di GKE Enterprise. Google Cloud

Prima di leggere questa pagina, assicurati di avere familiarità con Kubernetes.

Prima di iniziare

Per abilitare l'API Kubernetes Engine, segui questi passaggi:
  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Artifact Registry and Google Kubernetes Engine APIs.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Artifact Registry and Google Kubernetes Engine APIs.

    Enable the APIs

    8.

    Ruoli obbligatori

    Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.admin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.

    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

Avvia Cloud Shell

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

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

Avvia Cloud Shell:

  1. Vai alla 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 in un frame nella parte inferiore della console. Utilizza questa shell per eseguire i comandi gcloud e kubectl. Prima di eseguire i comandi, imposta il progetto predefinito in Google Cloud CLI utilizzando questo comando:

gcloud config set project PROJECT_ID

Sostituisci PROJECT_ID con l'ID progetto.

Crea un cluster GKE

Un cluster è costituito da almeno una macchina del control plane 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. Puoi eseguire il deployment delle applicazioni sui cluster e le applicazioni vengono eseguite sui nodi.

Questa sezione mostra come creare un cluster in modalità Autopilot, che è la modalità cluster consigliata per la maggior parte dei casi d'uso di produzione. In alternativa, puoi utilizzare un cluster in modalità GKE Standard per eseguire questi passaggi.

Crea un cluster Autopilot denominato hello-cluster:

gcloud container clusters create-auto hello-cluster \
    --location=us-central1

Il processo di creazione del cluster potrebbe richiedere alcuni minuti.

Recupera le credenziali di autenticazione per il cluster

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

gcloud container clusters get-credentials hello-cluster \
    --location us-central1

Questo comando configura kubectl per utilizzare il cluster che hai creato.

esegui 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 del deployment esegue l'immagine container hello-app.

In questo comando:

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

Esponi il deployment

Dopo aver eseguito il deployment dell'applicazione, devi esporla a internet in modo che gli utenti possano accedervi. Puoi esporre la tua applicazione creando un servizio, una risorsa Kubernetes che espone la tua applicazione al traffico esterno.

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

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

L'utilizzo del flag --type LoadBalancer crea un bilanciatore del carico Compute Engine per il container. Il flag --port inizializza la porta pubblica 80 su internet e il flag --target-port indirizza il traffico alla porta 8080 dell'applicazione.

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

Ispezionare e visualizzare l'applicazione

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

    kubectl get pods

    Dovresti vedere un pod hello-server in esecuzione sul 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 servizio 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.

Per monitorare e organizzare le risorse GKE in modo incentrato sulle applicazioni, puoi aggiungere le risorse come servizi e carichi di lavoro alle applicazioni App Hub.

Per ulteriori informazioni sulle risorse supportate da App Hub, vedi Risorse supportate.

Per scoprire come configurare App Hub nel tuo progetto, consulta Configurare App Hub.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, elimina il progetto Google Cloud con le risorse.

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

    kubectl delete service hello-server

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

  2. Elimina il cluster eseguendo gcloud container clusters delete:

    gcloud container clusters delete hello-cluster \
    --location us-central1

(Facoltativo) Revisione del codice hello-app

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

hello-app è pacchettizzato come immagine container Docker. Le immagini container vengono archiviate in qualsiasi registro di immagini Docker, come Artifact Registry. Ospitiamo hello-app in un repository Artifact Registry all'indirizzo 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 quale porta di rete dovrebbe essere esposta dall'app. Per ulteriori informazioni su come funziona questo file, consulta Riferimento a Dockerfile nella documentazione di Docker.

FROM golang:1.24.3 as builder
WORKDIR /app
RUN go mod init hello-app
COPY *.go ./
RUN CGO_ENABLED=0 GOOS=linux go build -o /hello-app

FROM gcr.io/distroless/base-debian11
WORKDIR /
COPY --from=builder /hello-app /hello-app
ENV PORT 8080
USER nonroot:nonroot
CMD ["/hello-app"]

Passaggi successivi

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di GKE in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti senza addebiti per l'esecuzione, il test e il deployment dei workload.

Prova GKE gratuitamente