Acest tutorial vă arată cum să împachetați o aplicație web într-o imagine de container Docker și să rulați acea imagine de container pe un cluster Google Kubernetes Engine (GKE). Apoi, implementați aplicația web ca un set echilibrat de replici care se pot scala la nevoile utilizatorilor dvs.

## Obiective
- Împachetați un exemplu de aplicație web într-o imagine Docker

- Încărcați imaginea Docker în Artifact Registry

- Creați un cluster GKE

- Implementați aplicația exemplu în cluster

- Gestionați scalarea automată pentru implementare

- Expuneți exemplul de aplicație la internet

- Implementați o nouă versiune a aplicației exemplu

## Cheltuieli
Acest tutorial folosește următoarele componente facturabile ale Google Cloud:
Pentru a genera o estimare a costurilor bazată pe utilizarea proiectată,
utilizați calculatorul de prețuri

Când terminați acest tutorial, puteți evita facturarea continuă ștergând resursele pe care le-ați creat. Pentru mai multe informații, consultați Curățare

## Înainte de a începeFaceți următorii pași pentru a activa API-ul Kubernetes Engine:
- Conectați-vă la contul dvs. Google Cloud. Dacă sunteți nou în Google Cloud, creați un cont pentru a evalua modul în care produsele noastre funcționează în scenarii din lumea reală. Clienții noi primesc, de asemenea, 300 USD în credite gratuite pentru a rula, a testa și a implementa sarcini de lucru

-
În consola Google Cloud, pe pagina de selectare a proiectelor, selectați sau creați un proiect Google Cloud

-
Asigurați-vă că facturarea este activată pentru proiectul dvs. Cloud. Aflați cum să verificați dacă facturarea este activată într-un proiect

-
Activați Artifact Registry și API-urile Google Kubernetes Engine

-
În consola Google Cloud, pe pagina de selectare a proiectelor, selectați sau creați un proiect Google Cloud

-
Asigurați-vă că facturarea este activată pentru proiectul dvs. Cloud. Aflați cum să verificați dacă facturarea este activată într-un proiect

-
Activați Artifact Registry și API-urile Google Kubernetes Engine

 Opțiunea A: Utilizați Cloud Shell
Puteți urma acest tutorial folosind Cloud Shell, care vine
preinstalat cu
gcloud,
docker, și
instrumentele din linia de comandă kubectl utilizate
în acest tutorial. Dacă utilizați Cloud Shell, nu este necesar să le instalați
instrumente de linie de comandă pe stația dvs. de lucru

Pentru a utiliza Cloud Shell:
- Accesați consola Google Cloud

Apasă pe
Activați Cloud Shell
butonul din partea de sus a ferestrei consolei Google Cloud

O sesiune Cloud Shell se deschide într-un nou cadru din partea de jos a consolei Google Cloud și afișează o linie de comandă promptă

 Opțiunea B: Folosiți instrumentele din linia de comandă la nivel local
Dacă preferați să urmați acest tutorial pe stația dvs. de lucru, urmați acești pași pentru a instala instrumentele necesare

Instalați CLI Google Cloud

Utilizând CLI gcloud, instalați instrumentul de linie de comandă Kubernetes
kubectlis folosit pentru a comunica cu Kubernetes, care este sistemul de orchestrare a clusterelor GKE:
Componentele gcloud instalează kubectl
Instalați Docker Community Edition (CE) pe stația dvs. de lucru. Utilizați acest lucru pentru a construi o imagine container pentru aplicație

Instalați instrumentul de control al sursei Git pentru a prelua aplicația exemplu de pe GitHub

## Creați un depozit
În acest tutorial, stocați o imagine în Artifact Registry și o implementați
din registru. Artifact Registry este registrul de container recomandat pe care îl are
Google Cloud. Pentru această pornire rapidă, veți crea un depozit numit
salut-repo

Seteaza
PROJECT_IDvariabila de mediu la ID-ul proiectului Google Cloud (
). Veți folosi această variabilă de mediu atunci când construiți imaginea containerului și o împingeți în depozit

PROJECT_ID
export PROJECT_ID=
PROJECT_ID
Confirmați că
Variabila de mediu PROJECT_ID are valoarea corectă:
echo $PROJECT_ID
Setați ID-ul proiectului pentru CLI Google Cloud:
Proiectul set de configurare gcloud $PROJECT_ID
Ieșire:
Proprietate actualizată [core/proiect]

Creați
hello-reporepository cu următoarea comandă:
depozitele de artefacte gcloud creează hello-repo \ --repository-format=docker \ --location=
REGION\ --description="Depozitul Docker"A inlocui
cu o regiune pentru depozit, cum ar fi
REGIUNE
noi-vest1. Pentru a vedea o listă de locații disponibile, rulați comanda:
lista de locații de artefacte gcloud
## Construirea imaginii containerului
În acest tutorial, implementați un exemplu de web
aplicația numită
hello-app, un server web scris
în Go care răspunde la toate solicitările cu mesajul
Salut Lume! pe portul 8080

GKE acceptă imaginile Docker ca format de implementare a aplicației

Înainte de desfășurare
salut-aplicație pentru GKE, trebuie să împachetați
cel
cod sursă al aplicației ca imagine Docker

Pentru a construi o imagine Docker, aveți nevoie de cod sursă și de un fișier Docker. Un Dockerfile conține instrucțiuni despre cum este construită imaginea

Descărcați
Hello-appsource cod și Dockerfile rulând următoarele comenzi:
git clone httpsgithub.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/hello-app
Creați și etichetați imaginea Docker pentru
salut-aplicație:
docker build -t
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1

Această comandă îi instruiește pe Docker să creeze imaginea folosind
Dockerfile în directorul curent, salvați-l în mediul local și etichetați-l cu un nume, cum ar fi
us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. Imaginea este împinsă în Artifact Registry în secțiunea următoare

- Cel
PROJECT_IDvariable asociază imaginea containerului cu
hello-repository din proiectul dvs. Google Cloud

- Cel
us-west1-docker.pkg.devprefix se referă la Artifact Registry, gazdă regională pentru depozitul dvs.

- Cel
Rulați
docker imagescommand pentru a verifica dacă construirea a avut succes:
imagini docker
Ieșire:
Etichetă de depozitare ID IMAGINE DIMENSIUNE CREAȚĂ us-west1-docker.pkg.dev/my-project/hello-repo/hello-app v1 25cfadb1bf28 Acum 10 secunde 54 MB
## Rularea containerului local (opțional)
Testați imaginea containerului folosind motorul local Docker:
docker run --rm -p 8080:8080
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
Dacă utilizați Cloud Shell, faceți clic pe
Butonul de previzualizare web
și apoi selectați
8080 număr de port. GKE deschide adresa URL de previzualizare a serviciului său proxy într-o nouă fereastră de browser

În caz contrar, deschideți o nouă fereastră de terminal (sau o filă Cloud Shell) și rulați următoarea comandă pentru a verifica dacă containerul funcționează și răspunde la solicitări cu „Bună ziua, lume
curl httplocalhost:8080
După ce ați văzut un răspuns de succes, puteți coborî containerul apăsând
Ctrl+Cin fila unde este
docker runcommand rulează

## Împingeți imaginea Docker în Artifact Registry
Trebuie să încărcați imaginea containerului într-un registru, astfel încât clusterul dvs. GKE să poată descărca și rula imaginea containerului. În acest tutorial, vă veți stoca containerul în Artifact Registry

Configurați instrumentul de linie de comandă Docker pentru a se autentifica la Artifact Registry:
gcloud auth configure-docker
REGION-docker.pkg.dev
Împingeți imaginea Docker pe care tocmai ați creat-o în depozit:
docker push
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
## Crearea unui cluster GKE
Acum că imaginea Docker este stocată în Artifact Registry, creați un GKE
cluster
a alerga
salut-aplicație. Un cluster GKE este format dintr-un grup de instanțe VM Compute Engine
rulează Kubernetes, orchestrația de cluster open source
sistem care alimentează GKE

 Cloud Shell
Setați zona sau regiunea Compute Engine. În funcție de modul de operare pe care alegeți să îl utilizați în GKE, specificați o zonă sau o regiune prestabilită. Dacă utilizați modul Standard, clusterul dvs. este zonal (pentru acest tutorial), așa că setați zona de calcul implicită. Dacă utilizați modul Autopilot, clusterul dvs. este regional, așa că setați regiunea de calcul implicită. Alegeți o zonă sau o regiune care este cea mai apropiată de depozitul Artifact Registry pe care l-ați creat

Standardcluster, cum ar fi
us-west1-a:
set de configurare gcloud compute/zone
Cluster de pilot automat COMPUTE_ZONE, cum ar fi
noi-vest1:
set de configurare gcloud compute/region
COMPUTE_REGION
-
Creați un cluster numit
salut-cluster:
Cluster standard:
clusterele de containere gcloud creează hello-cluster
Cluster de pilot automat:
clustere de containere gcloud create-auto hello-cluster
Este nevoie de câteva minute pentru ca clusterul dvs. GKE să fie creat și verificat

-
După finalizarea comenzii, rulați următoarea comandă pentru a vedea cele trei noduri ale clusterului:
kubectl obține noduri
Ieșire:
NUME STAREA ROLURI VÂRSTA VERSIUNE gke-hello-cluster-default-pool-229c0700-cbtd Gata 92s v1.18.12-gke.1210 gke-hello-cluster-default-pool-229c0700-fc5j Ready  91s v1.18.12-gke.1210 gke-hello-cluster-default-pool-229c0700-n9l7 Ready  92s v1.18.12-gke.1210
 Console
Go to the
Google Kubernetes Enginepage in the Google Cloud console

Go to Google Kubernetes Engine
Click
Create

Choose Standard or Autopilot mode and click
Configure

In the
Namefield, enter the name
hello-cluster

Select a zone or region:
Standardcluster: Under Location type, select Zonaland then select a Compute Engine zone from the Zonedrop-down list, such as
us-west1-a

Autopilotcluster: Select a Compute Engine region from the Regiondrop-down list, such as
us-west1

-
Click
Create. This creates a GKE cluster

Wait for the cluster to be created. When the cluster is ready, a green check mark appears next to the cluster name

## Deploying the sample app to GKE
You are now ready to deploy the Docker image you built to your GKE cluster

Kubernetes represents applications as Pods, which are scalable units holding one or more containers. The Pod is the smallest deployable unit in Kubernetes. Usually, you deploy Pods as a set of replicas that can be scaled and distributed together across your cluster. One way to deploy a set of replicas is through a Kubernetes Deployment

In this section, you create a Kubernetes Deployment to run
hello-app on your
cluster. This Deployment has replicas (Pods). One Deployment Pod contains only
one container: the
hello-app Docker image

You also create a HorizontalPodAutoscaler resource that scales the number
of Pods from 3 to a number between 1 and 5, based on CPU load

 Cloud Shell
Ensure that you are connected to your GKE cluster

gcloud container clusters get-credentials hello-cluster --zone
COMPUTE_ZONE
Create a Kubernetes Deployment for your
hello-appDocker image

kubectl create deployment hello-app --image=
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
Set the baseline number of Deployment replicas to 3

kubectl scale deployment hello-app --replicas=3
Create a
HorizontalPodAutoscalerresource for your Deployment

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
To see the Pods created, run the following command:
kubectl get pods
Output:
NAME READY STATUS RESTARTS AGE hello-app-784d7569bc-hgmpx 1/1 Running 0 10s hello-app-784d7569bc-jfkz5 1/1 Running 0 10s hello-app-784d7569bc-mnrrl 1/1 Running 0 15s
 Console
Go to the
Workloadspage in the Google Cloud console

Click
Deploy

In the
Specify containersection, select Existing container image

In the
Image pathfield, click Select

In the
Select container imagepane, select the
hello-appimage you pushed to Artifact Registry and click
Select

In the
Containersection, click Done, then click Continue

In the
Configurationsection, under Labels, enter
appfor
Keyand
hello-appfor
Value

Under
Configuration YAML, click View YAML. This opens a YAML configuration file representing the two Kubernetes API resources about to be deployed into your cluster: one Deployment, and one
HorizontalPodAutoscalerfor that Deployment

Click
Close, then click Deploy

When the Deployment Pods are ready, the
Deployment detailspage opens

Under
Managed pods, note the three running Pods for the
hello-appDeployment

## Exposing the sample app to the internet
While Pods do have individually-assigned IP addresses, those IPs can only be reached from inside your cluster. Also, GKE Pods are designed to be ephemeral, starting or stopping based on scaling needs. And when a Pod crashes due to an error, GKE automatically redeploys that Pod, assigning a new Pod IP address each time

What this means is that for any Deployment, the set of IP addresses corresponding to the active set of Pods is dynamic. We need a way to 1) group Pods together into one static hostname, and 2) expose a group of Pods outside the cluster, to the internet

Kubernetes Services solve for both of these problems

Services group Pods
into one static IP address, reachable from any Pod inside the cluster

GKE also assigns a DNS hostname
to that static IP. For example,
hello-app.default.svc.cluster.local

The default Service type in GKE is called ClusterIP,
where the Service gets an IP address reachable only from inside the cluster

To expose a Kubernetes Service outside the cluster, create a Service of
type
LoadBalancer

This type of Service spawns an External Load Balancer IP for a set of Pods,
reachable through the internet

In this section, you expose the
hello-app Deployment to the internet using a
Service of type
LoadBalancer

 Cloud Shell
Use the
kubectl exposecommand to generate a Kubernetes Service for the
hello-appdeployment:
kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
Here, the
--portflag specifies the port number configured on the Load Balancer, and the
--target-portflag specifies the port number that the
hello-appcontainer is listening on

Run the following command to get the Service details for
hello-app-service:
kubectl get service
Output:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-app-service 10.3.251.122 203.0.113.0 80:30877/TCP 10s
Copy the
EXTERNAL_IPaddress to the clipboard (for instance:
203.0.113.0)

 Console
Go to the
Workloadspage in the Google Cloud console

Click
hello-app

From the Deployment details page, click
Actions > Expose

In the
Exposedialog, set the Target portto
8080. This is the port the
hello-appcontainer listens on

From the
Service typedrop-down list, select Load balancer

Click
Exposeto create a Kubernetes Service for
hello-app

When the Load Balancer is ready, the
Service detailspage opens

Scroll down to the
External endpointsfield, and copy the IP address

Now that the
hello-app Pods are exposed to the internet through a Kubernetes Service,
you can open a new browser tab, and navigate to the Service IP address you copied
to the clipboard. A
Hello, World! message appears, along with a
Hostname
field. The
Hostname corresponds to one of the three
hello-app Pods serving your
HTTP request to your browser

## Deploying a new version of the sample app
In this section, you upgrade
hello-app to a new version by building and deploying
a new Docker image to your GKE cluster

GKE's rolling update feature
lets you update your Deployments without downtime. During a rolling update, your GKE cluster
incrementally replaces the existing
hello-app Pods with Pods containing the Docker image for the new version

During the update, your load balancer service routes traffic only into available Pods

Return to Cloud Shell, where you have cloned the hello app source code and Dockerfile. Update the function
hello()in the
main.gofile to report the new version
2.0.0

Build and tag a new
hello-appDocker image

docker build -t
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2 

Push the image to Artifact Registry

docker push
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2
Now you're ready to update your
hello-app Kubernetes Deployment to use a new Docker image

 Cloud Shell
Apply a rolling update to the existing
hello-appDeployment with an image update using the
kubectl set imagecommand:
kubectl set image deployment/hello-app hello-app=
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2
Watch the running Pods running the
v1image stop, and new Pods running the
v2image start

watch kubectl get pods
Output:
NAME READY STATUS RESTARTS AGE hello-app-89dc45f48-5bzqp 1/1 Running 0 2m42s hello-app-89dc45f48-scm66 1/1 Running 0 2m40s
In a separate tab, navigate again to the
hello-app-serviceExternal IP. You should now see the
Versionset to
2.0.0

 Console
Go to the
Workloadspage in the Google Cloud console

Click
hello-app

On the

Deployment detailspage, click Actions > Rolling update

In the
Rolling updatedialog, set the Image of hello-appfield to


REGION-docker.pkg.dev/ PROJECT_ID/hello-repo/hello-app:v2
Click
Update

On the
Deployment detailspage, inspect the Active Revisionssection. You should now see two Revisions, 1 and 2. Revision 1 corresponds to the initial Deployment you created earlier. Revision 2 is the rolling update you just started

After a few moments, refresh the page. Under
Managed pods, all of the replicas of
hello-appnow correspond to Revision 2

In a separate tab, navigate again to the Service IP address you copied. The
Versionshould be
2.0.0

## Clean up
To avoid incurring charges to your Google Cloud account for the resources used in this tutorial, either delete the project that contains the resources, or keep the project and delete the individual resources

Delete the Service:This deallocates the Cloud Load Balancer created for your Service:
kubectl delete service hello-app-service
Delete the cluster:This deletes the resources that make up the cluster, such as the compute instances, disks, and network resources:
gcloud container clusters delete hello-cluster --zone
COMPUTE_ZONE Delete your container images:This deletes the Docker images you pushed to Artifact Registry

gcloud artifacts docker images delete REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1 \ --delete-tags --quiet gcloud artifacts docker images delete \ REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2 \ --delete-tags --quiet
## What's next
Learn about Pricing for GKE and use the Pricing Calculator to estimate costs

Read the Load Balancers tutorial, which demonstrates advanced load balancing configurations for web applications

Configure a static IP and domain name for your application

Explore other Kubernetes Engine tutorials

Explore reference architectures, diagrams, tutorials, and best practices about Google Cloud. Take a look at our Cloud Architecture Center

## Try it for yourself
If you're new to Google Cloud, create an account to evaluate how GKE performs in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.Try GKE free