Esegui il deployment di un'app in un cluster GKE

Esegui il deployment di un'app in un cluster GKE

Autopilot . Standard

---

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

Questa guida rapida presuppone una conoscenza di base di Kubernetes.

Prima di iniziare

Per abilitare l'API Kubernetes Engine, segui questi passaggi:

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

   Abilita le API

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

   Abilita le API

Avvia Cloud Shell

In questo tutorial utilizzerai Cloud Shell, che è un ambiente shell per la gestione delle risorse in hosting in Google Cloud.

Cloud Shell è preinstallato Google Cloud CLI e kubectl a strumento a riga di comando. gcloud CLI fornisce la riga di comando per Google Cloud e kubectl fornisce la riga di comando per eseguire comandi sui cluster Kubernetes.

Avvia Cloud Shell:

1. Vai alla console Google Cloud.

   Console Google Cloud

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

Si apre una sessione di Cloud Shell all'interno di un frame più in basso nella console. Utilizzerai questa shell per eseguire i comandi gcloud e kubectl. Prima di eseguire i comandi, imposta il progetto predefinito in Google Cloud CLI utilizzando il seguente comando:

gcloud config set project PROJECT_ID

Sostituisci PROJECT_ID con il tuo ID progetto.

Crea un cluster GKE

Un cluster è composto da almeno una macchina del piano di controllo del cluster e più e macchine worker denominate nodi. I nodi sono Istanze di macchine virtuali (VM) Compute Engine che eseguono i processi Kubernetes necessari farli parte del cluster. Puoi eseguire il deployment delle applicazioni sui cluster e le applicazioni vengono eseguite sui nodi.

Crea un cluster Autopilot denominato hello-cluster:

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

Nota: il completamento della creazione del cluster potrebbe richiedere diversi minuti.

Recupera le credenziali di autenticazione per il cluster

Dopo aver creato il cluster, devi ottenere le credenziali di autenticazione interagiscono con il cluster:

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

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

esegui il deployment di un'applicazione nel cluster

Ora che hai creato un cluster, puoi eseguire il deployment un'applicazione containerizzata che le sono assegnati. Per questa guida rapida, puoi eseguire il deployment del nostro database applicazione, hello-app.

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

crea il deployment

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

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

Questo comando Kubernetes, kubectl create deployment, crea un deployment denominato hello-server. Lo spazio di archiviazione Pod esegue l'immagine container hello-app.

In questo comando:

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

Esponi il deployment

Dopo aver eseguito il deployment dell'applicazione, devi esporla a internet in modo che a cui possono accedere gli utenti. Puoi esporre l'applicazione creando un servizio, un 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

Il passaggio del flag --type LoadBalancer crea un ambiente Compute Engine con il bilanciatore del carico più alto per il tuo container. Il flag --port viene inizializzato come pubblico la porta 80 a internet e il flag --target-port instrada il traffico verso alla porta 8080 dell'applicazione.

I bilanciatori del carico vengono fatturati in base prezzi dei bilanciatori del carico.

Ispeziona e visualizza l'applicazione

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

   kubectl get pods
   

   Dovresti vedere 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 servizio Colonna EXTERNAL-IP.

   Nota: potrebbe essere necessario attendere diversi minuti prima che il servizio viene compilato un indirizzo IP esterno. Se l'IP esterno dell'applicazione è <pending>, esegui di nuovo kubectl get.

3. Visualizza l'applicazione dal tuo 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 con GKE.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi per le 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 Compute Engine, creato al momento dell'esposizione del deployment.

2. Elimina il cluster eseguendo gcloud container clusters delete:

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

Facoltativo: hello-app revisione del codice

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

hello-app è pacchettizzato come Docker nell'immagine container. Le immagini container sono archiviate in qualsiasi registro di immagini Docker, come Artifact Registry. Ospitiamo hello-app in un repository Artifact Registry su 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!". per creare un nuovo messaggio email.

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 relative risorse e dipendenze e specifica la porta di rete a cui l'app l'esposizione. Per ulteriori informazioni sul funzionamento di questo file, vedi Riferimento Dockerfile nella documentazione Docker.

FROM golang:1.21.0 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

• Scopri di più sulla creazione di cluster.
• Scopri di più su Kubernetes.
• Scopri come pacchettizzare, ospitare e implementare una semplice applicazione server web.
• Esegui il deployment di un'applicazione Kubernetes con Cloud Code for VS Code o Cloud Code for IntelliJ.
• Scopri come Replatforming delle applicazioni Linux nei container.

Provalo

Se non hai mai utilizzato Google Cloud, crea un account per valutare in che modo GKE si comporta nel mondo reale diversi scenari. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova GKE gratuitamente