Questa pagina mostra come creare servizi Kubernetes in un cluster Google Kubernetes Engine (GKE). Per una spiegazione del concetto di servizio e una discussione sui vari tipi di servizi, consulta Servizio.
Introduzione
L'idea di un servizio è raggruppare un insieme di endpoint di pod in un'unica risorsa. Puoi configurare vari modi per accedere al raggruppamento. Per impostazione predefinita, ottieni un indirizzo IP cluster stabile che i client all'interno del cluster possono utilizzare per contattare i pod nel servizio. Un client invia una richiesta all'indirizzo IP stabile e la richiesta viene inoltrata a uno dei pod del servizio.
Esistono cinque tipi di servizi:
- ClusterIP (predefinito)
- NodePort
- LoadBalancer
- ExternalName
- Headless
I cluster Autopilot sono pubblici per impostazione predefinita. Se scegli un cluster Autopilot privato, devi configurare Cloud NAT per effettuare connessioni a internet in uscita, ad esempio per estrarre immagini da DockerHub.
Questo argomento contiene diversi esercizi. In ogni esercizio, crei un deployment e ne mostri i pod creando un servizio. Poi invii una richiesta HTTP al servizio.
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:
- Attiva l'API Google Kubernetes Engine. Attiva l'API Google Kubernetes Engine
- Se vuoi utilizzare Google Cloud CLI per questa attività,
installa e poi
inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo
gcloud components update
.
Creazione di un servizio di tipo ClusterIP
In questa sezione, crei un servizio di tipo
ClusterIP
.
kubectl apply
Ecco un manifest per un deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-deployment
spec:
selector:
matchLabels:
app: metrics
department: sales
replicas: 3
template:
metadata:
labels:
app: metrics
department: sales
spec:
containers:
- name: hello
image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
Copia il manifest in un file denominato my-deployment.yaml
e crea il deployment:
kubectl apply -f my-deployment.yaml
Verifica che siano in esecuzione tre pod:
kubectl get pods
L'output mostra tre pod in esecuzione:
NAME READY STATUS RESTARTS AGE
my-deployment-dbd86c8c4-h5wsf 1/1 Running 0 7s
my-deployment-dbd86c8c4-qfw22 1/1 Running 0 7s
my-deployment-dbd86c8c4-wt4s6 1/1 Running 0 7s
Ecco un manifest per un servizio di tipo ClusterIP
:
apiVersion: v1
kind: Service
metadata:
name: my-cip-service
spec:
type: ClusterIP
# Uncomment the below line to create a Headless Service
# clusterIP: None
selector:
app: metrics
department: sales
ports:
- protocol: TCP
port: 80
targetPort: 8080
Il servizio ha un selettore che specifica due etichette:
app: metrics
department: sales
Ogni pod nel deployment creato in precedenza ha queste due etichette. Di conseguenza, i pod nel deployment diventeranno membri di questo servizio.
Copia il manifest in un file denominato my-cip-service.yaml
e crea il servizio:
kubectl apply -f my-cip-service.yaml
Attendi un momento affinché Kubernetes assegni un indirizzo interno stabile al servizio, quindi visualizza il servizio:
kubectl get service my-cip-service --output yaml
L'output mostra un valore per clusterIP
:
spec:
clusterIP: 10.59.241.241
Prendi nota del valore di clusterIP
per un utilizzo futuro.
Console
Creazione di un deployment
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Fai clic su add_box Esegui il deployment.
In Specifica contenitore, seleziona Immagine container esistente.
In Percorso immagine, inserisci
us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
Fai clic su Fine, quindi su Continua.
In Configurazione, in Nome dell'applicazione, inserisci
my-deployment
.In Etichette, crea le seguenti etichette:
- Chiave:
app
e Valore:metrics
- Chiave:
department
e Valore:sales
- Chiave:
In Cluster, scegli il cluster in cui vuoi creare il deployment.
Fai clic su Esegui il deployment.
Quando il deployment è pronto, viene aperta la pagina Dettagli deployment. In Pod gestiti, puoi vedere che il tuo deployment ha uno o più pod in esecuzione.
Crea un servizio per esporre il deployment
- Nella pagina Dettagli deployment, fai clic su list Azioni > Esponi.
Nella finestra di dialogo Esponi, in Mappatura delle porte, imposta i seguenti valori:
- Porta:
80
- Porta target:
8080
- Protocollo:
TCP
- Porta:
Nell'elenco a discesa Tipo di servizio, seleziona IP cluster.
Fai clic su Esponi.
Quando il servizio è pronto, viene aperta la pagina Dettagli del servizio, dove puoi visualizzarne i dettagli. In IP del cluster, prendi nota dell'indirizzo IP assegnato da Kubernetes al tuo servizio. Si tratta dell'indirizzo IP che i client interni possono utilizzare per chiamare il servizio.
Accedere al servizio
Elenca i pod in esecuzione:
kubectl get pods
Nell'output, copia uno dei nomi dei pod che inizia con my-deployment
.
NAME READY STATUS RESTARTS AGE
my-deployment-dbd86c8c4-h5wsf 1/1 Running 0 2m51s
Apri una shell in uno dei container in esecuzione:
kubectl exec -it POD_NAME -- sh
Sostituisci POD_NAME
con il nome di uno dei pod in
my-deployment
.
Nella shell, installa curl
:
apk add --no-cache curl
Nel contenitore, invia una richiesta al servizio utilizzando l'indirizzo IP del cluster e la porta 80. Tieni presente che 80 è il valore del campo port
del servizio. Si tratta della porta che utilizzi come client del servizio.
curl CLUSTER_IP:80
Sostituisci CLUSTER_IP
con il valore di clusterIP
nel servizio.
La richiesta viene inoltrata a uno dei pod membri sulla porta TCP 8080, che è il valore del campo targetPort
. Tieni presente che ogni pod membro del servizio deve avere un container in ascolto sulla porta 8080.
La risposta mostra l'output di hello-app
:
Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-h5wsf
Per uscire dalla shell e tornare al contenitore, inserisci exit
.
Creazione di un servizio di tipo NodePort
In questa sezione, crei un servizio di tipo
NodePort
.
kubectl apply
Ecco un manifest per un deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-deployment-50000
spec:
selector:
matchLabels:
app: metrics
department: engineering
replicas: 3
template:
metadata:
labels:
app: metrics
department: engineering
spec:
containers:
- name: hello
image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
env:
- name: "PORT"
value: "50000"
Nota l'oggetto env
nel manifest. L'oggetto env
specifica che la variabile di ambiente PORT
per il contenitore in esecuzione avrà un valore 50000
. L'applicazione hello-app
esegue l'ascolto sulla porta specificata dalla variabile di ambiente PORT
. In questo esercizio, stai dicendo al
container di rimanere in ascolto sulla porta 50000.
Copia il manifest in un file denominato my-deployment-50000.yaml
e crea il deployment:
kubectl apply -f my-deployment-50000.yaml
Verifica che siano in esecuzione tre pod:
kubectl get pods
Ecco un manifest per un servizio di tipo NodePort:
apiVersion: v1
kind: Service
metadata:
name: my-np-service
spec:
type: NodePort
selector:
app: metrics
department: engineering
ports:
- protocol: TCP
port: 80
targetPort: 50000
Copia il manifest in un file denominato my-np-service.yaml
e crea il servizio:
kubectl apply -f my-np-service.yaml
Visualizza il servizio:
kubectl get service my-np-service --output yaml
L'output mostra un valore nodePort
:
...
spec:
...
ports:
- nodePort: 30876
port: 80
protocol: TCP
targetPort: 50000
selector:
app: metrics
department: engineering
sessionAffinity: None
type: NodePort
...
Crea una regola firewall per consentire il traffico TCP sulla porta del tuo nodo:
gcloud compute firewall-rules create test-node-port \
--allow tcp:NODE_PORT
Sostituisci NODE_PORT
con il valore del campo nodePort
del tuo servizio.
Console
Creazione di un deployment
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Fai clic su add_box Esegui il deployment.
In Specifica contenitore, seleziona Immagine container esistente.
In Percorso immagine, inserisci
us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
.Fai clic su add Aggiungi variabile di ambiente.
In Chiave, inserisci
PORT
e in Valore, inserisci50000
.Fai clic su Fine, quindi su Continua.
In Configurazione, in Nome dell'applicazione, inserisci
my-deployment-50000
.In Etichette, crea le seguenti etichette:
- Chiave:
app
e Valore:metrics
- Chiave:
department
e Valore:engineering
- Chiave:
In Cluster, scegli il cluster in cui vuoi creare il deployment.
Fai clic su Esegui il deployment.
Quando il deployment è pronto, viene aperta la pagina Dettagli deployment. In Pod gestiti, puoi vedere che il tuo deployment ha uno o più pod in esecuzione.
Crea un servizio per esporre il deployment
- Nella pagina Dettagli deployment, fai clic su list Azioni > Esponi.
Nella finestra di dialogo Esponi, in Mappatura delle porte, imposta i seguenti valori:
- Porta:
80
- Porta target:
50000
- Protocollo:
TCP
- Porta:
Nell'elenco a discesa Tipo di servizio, seleziona Porta del nodo.
Fai clic su Esponi.
Quando il servizio è pronto, viene aperta la pagina Dettagli del servizio, dove puoi visualizzarne i dettagli. In Porte, prendi nota della Porta del nodo assegnata da Kubernetes al tuo servizio.
Crea una regola firewall per la porta del tuo nodo
Vai alla pagina Criteri firewall nella console Google Cloud.
Fai clic su add_box Crea regola firewall.
In Nome, inserisci
test-node-port
.Nell'elenco a discesa Destinazioni, seleziona Tutte le istanze nella rete.
In Intervalli IPv4 di origine, inserisci
0.0.0.0/0
.In Protocolli e porte, seleziona Protocolli e porte specificati.
Seleziona la casella di controllo tcp e inserisci il valore della porta del nodo che hai annotato.
Fai clic su Crea.
Ottenere un indirizzo IP del nodo
Trova l'indirizzo IP esterno di uno dei tuoi nodi:
kubectl get nodes --output wide
L'output è simile al seguente:
NAME STATUS ROLES AGE VERSION EXTERNAL-IP
gke-svc-... Ready none 1h v1.9.7-gke.6 203.0.113.1
Non tutti i cluster hanno indirizzi IP esterni per i nodi. Ad esempio, se hai attivato i nodi privati, i nodi non avranno indirizzi IP esterni.
Accedere al servizio
Nella barra degli indirizzi del browser, inserisci quanto segue:
NODE_IP_ADDRESS:NODE_PORT
Sostituisci quanto segue:
NODE_IP_ADDRESS
: l'indirizzo IP esterno di uno dei tuoi nodi, trovato durante la creazione del servizio nell'attività precedente.NODE_PORT
: il valore della porta del nodo.
L'output è simile al seguente:
Hello, world!
Version: 2.0.0
Hostname: my-deployment-50000-6fb75d85c9-g8c4f
Creazione di un servizio di tipo LoadBalancer
In questa sezione, crei un servizio di tipo
LoadBalancer
.
kubectl apply
Ecco un manifest per un deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-deployment-50001
spec:
selector:
matchLabels:
app: products
department: sales
replicas: 3
template:
metadata:
labels:
app: products
department: sales
spec:
containers:
- name: hello
image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
env:
- name: "PORT"
value: "50001"
Tieni presente che i container in questo deployment ascolteranno sulla porta 50001.
Copia il manifest in un file denominato my-deployment-50001.yaml
e crea il deployment:
kubectl apply -f my-deployment-50001.yaml
Verifica che siano in esecuzione tre pod:
kubectl get pods
Ecco un manifest per un servizio di tipo LoadBalancer
:
apiVersion: v1
kind: Service
metadata:
name: my-lb-service
spec:
type: LoadBalancer
selector:
app: products
department: sales
ports:
- protocol: TCP
port: 60000
targetPort: 50001
Copia il manifest in un file denominato my-lb-service.yaml,
e crea il servizio:
kubectl apply -f my-lb-service.yaml
Quando crei un servizio di tipo LoadBalancer
, un controller Google Cloud si attiva e configura un bilanciatore del carico di rete passthrough esterno.
Attendi un minuto per consentire al controller di configurare il bilanciatore del carico di rete passthrough esterno e
generare un indirizzo IP stabile.
Visualizza il servizio:
kubectl get service my-lb-service --output yaml
L'output mostra un indirizzo IP esterno stabile in loadBalancer:ingress
:
...
spec:
...
ports:
- ...
port: 60000
protocol: TCP
targetPort: 50001
selector:
app: products
department: sales
sessionAffinity: None
type: LoadBalancer
status:
loadBalancer:
ingress:
- ip: 203.0.113.10
Console
Creazione di un deployment
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Fai clic su add_box Esegui il deployment.
In Specifica contenitore, seleziona Immagine container esistente.
In Percorso immagine, inserisci
us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
.Fai clic su add Aggiungi variabile di ambiente.
In Chiave, inserisci
PORT
e in Valore, inserisci50001
.Fai clic su Fine, quindi su Continua.
In Configurazione, in Nome dell'applicazione, inserisci
my-deployment-50001
.In Etichette, crea le seguenti etichette:
- Chiave:
app
e Valore:products
- Chiave:
department
e Valore:sales
- Chiave:
In Cluster, scegli il cluster in cui vuoi creare il deployment.
Fai clic su Esegui il deployment.
Quando il deployment è pronto, viene aperta la pagina Dettagli deployment. In Pod gestiti, puoi vedere che il tuo deployment ha uno o più pod in esecuzione.
Crea un servizio per esporre il deployment
- Nella pagina Dettagli deployment, fai clic su list Azioni > Esponi.
Nella finestra di dialogo Esponi, in Mappatura delle porte, imposta i seguenti valori:
- Porta:
60000
- Porta target:
50001
- Protocollo:
TCP
- Porta:
Nell'elenco a discesa Tipo di servizio, seleziona Bilanciatore del carico.
Fai clic su Esponi.
Quando il servizio è pronto, viene aperta la pagina Dettagli del servizio, dove puoi visualizzarne i dettagli. In Bilanciatore del carico, prendi nota dell'indirizzo IP esterno del bilanciatore del carico.
Accedere al servizio
Attendi qualche minuto per consentire a GKE di configurare il bilanciatore del carico.
Nella barra degli indirizzi del browser, inserisci quanto segue:
LOAD_BALANCER_ADDRESS:60000
Sostituisci LOAD_BALANCER_ADDRESS
con l'indirizzo IP esterno del bilanciatore del carico.
La risposta mostra l'output di hello-app
:
Hello, world!
Version: 2.0.0
Hostname: my-deployment-50001-68bb7dfb4b-prvct
Tieni presente che il valore di port
in un servizio è arbitrario. L'esempio precedente lo dimostra utilizzando un valore port
pari a 60000.
Creazione di un servizio di tipo ExternalName
In questa sezione, crei un servizio di tipo
ExternalName
.
Un servizio di tipo ExternalName
fornisce un alias interno per un nome DNS esterno. I client interni inviano richieste utilizzando il nome DNS interno e le richieste vengono reindirizzate al nome esterno.
Ecco un manifest per un servizio di tipo ExternalName
:
apiVersion: v1
kind: Service
metadata:
name: my-xn-service
spec:
type: ExternalName
externalName: example.com
Nell'esempio precedente, il nome DNS è my-xn-service.default.svc.cluster.local. Quando un client interno invia una richiesta a my-xn-service.default.svc.cluster.local, la richiesta viene reindirizzata a example.com.
Utilizzo di kubectl expose
per creare un servizio
In alternativa alla scrittura di un manifest del servizio, puoi creare un servizio utilizzando kubectl expose
per esporre un deployment.
Per esporre my-deployment
, mostrato in precedenza in questo argomento, puoi inserire questo
comando:
kubectl expose deployment my-deployment --name my-cip-service \
--type ClusterIP --protocol TCP --port 80 --target-port 8080
Per esporre my-deployment-50000
, mostrato in precedenza in questo argomento, puoi inserire questo comando:
kubectl expose deployment my-deployment-50000 --name my-np-service \
--type NodePort --protocol TCP --port 80 --target-port 50000
Per esporre my-deployment-50001
, mostrato in precedenza in questo argomento, puoi inserire questo comando:
kubectl expose deployment my-deployment-50001 --name my-lb-service \
--type LoadBalancer --port 60000 --target-port 50001
Pulizia
Dopo aver completato gli esercizi in questa pagina, segui questi passaggi per rimuovere le risorse ed evitare addebiti indesiderati sul tuo account:
kubectl apply
Eliminare i servizi
kubectl delete services my-cip-service my-np-service my-lb-service
Eliminazione dei deployment
kubectl delete deployments my-deployment my-deployment-50000 my-deployment-50001
Eliminazione della regola firewall
gcloud compute firewall-rules delete test-node-port
Console
Eliminare i servizi
Vai alla pagina Servizi nella console Google Cloud.
Seleziona i servizi che hai creato in questo esercizio, quindi fai clic su delete Elimina.
Quando ti viene richiesto di confermare, fai clic su Elimina.
Eliminazione dei deployment
Vai alla pagina Carichi di lavoro nella console Google Cloud.
Seleziona i deployment che hai creato in questo esercizio, quindi fai clic su delete Elimina.
Quando ti viene chiesto di confermare, seleziona la casella di controllo Elimina Horizontal Pod Autoscaler associati ai deployment selezionati e fai clic su Elimina.
Eliminazione della regola firewall
Vai alla pagina Criteri firewall nella console Google Cloud.
Seleziona la casella di controllo test-node-port, quindi fai clic su delete Elimina.
Quando ti viene richiesto di confermare, fai clic su Elimina.