Per esporre le tue applicazioni e instradare il traffico HTTP(S) esterno ai workload nei cluster utente di Google Distributed Cloud, puoi creare un Ingress e un Service Kubernetes. Ingress indirizza le richieste client in entrata ai servizi, che poi inoltrano il traffico ai pod sottostanti. Questo documento mostra come creare un deployment di esempio, esporlo con un servizio, instradare le richieste con un Ingress e quindi configurare HTTPS per Ingress.
Prima di iniziare
Stabilisci una connessione SSH alla tua workstation di amministrazione.
Creazione di un deployment
Ecco un manifest per un deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-deployment
spec:
selector:
matchLabels:
greeting: hello
replicas: 3
template:
metadata:
labels:
greeting: hello
spec:
containers:
- name: hello-world
image: "gcr.io/google-samples/hello-app:2.0"
env:
- name: "PORT"
value: "50000"
- name: hello-kubernetes
image: "gcr.io/google-samples/node-hello:1.0"
env:
- name: "PORT"
value: "8080"
Ai fini di questo esercizio, ecco i punti importanti da comprendere sul manifest del deployment:
Ogni pod appartenente al deployment ha l'etichetta
greeting: hello.Ogni pod ha due container.
I campi
envspecificano che i containerhello-appsono in ascolto sulla porta TCP 50000 e i containernode-hellosono in ascolto sulla porta TCP 8080. Perhello-app, puoi vedere l'effetto della variabile di ambientePORTesaminando il codice sorgente di hello-app.
Copia il manifest in un file denominato hello-deployment.yaml e crea il deployment:
kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f hello-deployment.yaml
dove USER_CLUSTER_KUBECONFIG è il percorso del file kubeconfig per il tuo cluster utente.
Esponi il deployment con un servizio
Per fornire ai client un modo stabile per inviare richieste ai pod del tuo deployment, crea un servizio.
Ecco un manifest per un servizio che espone il tuo deployment ai client all'interno del cluster:
apiVersion: v1
kind: Service
metadata:
name: hello-service
spec:
type: ClusterIP
selector:
greeting: hello
ports:
- name: world-port
protocol: TCP
port: 60000
targetPort: 50000
- name: kubernetes-port
protocol: TCP
port: 60001
targetPort: 8080
Copia il manifest in un file denominato hello-service.yaml e crea il servizio:
kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f hello-service.yaml
Visualizza il servizio:
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get service hello-service --output yaml
L'output mostra il valore di clusterIP assegnato al servizio.
Ad esempio:
apiVersion: v1
kind: Service
metadata:
annotations:
...
spec:
clusterIP: 10.96.14.249
clusterIPs:
- 10.96.14.249
ipFamilies:
- IPv4
ipFamilyPolicy: SingleStack
ports:
- name: world-port
port: 60000
protocol: TCP
targetPort: 50000
- name: kubernetes-port
port: 60001
protocol: TCP
targetPort: 8080
selector:
greeting: hello
sessionAffinity: None
type: ClusterIP
status:
loadBalancer: {}
Nell'output precedente, il campo ports è un array di oggetti Kubernetes
ServicePort: uno denominato world-port e uno denominato kubernetes-port.
Ecco i modi in cui un client può chiamare il servizio:
Utilizzo di
world-port: un client in esecuzione su uno dei nodi del cluster invia una richiesta aclusterIPsuport. In questo esempio, 10.96.14.249:60000. La richiesta viene inoltrata a un pod membro sutargetPort. In questo esempio, POD_IP_ADDRESS:50000.Utilizzo di
kubernetes-port: un client in esecuzione su uno dei nodi del cluster invia una richiesta aclusterIPsuport. In questo esempio, 10.96.14.249:60001. La richiesta viene inoltrata a un pod membro sutargetPort. In questo esempio, POD_IP_ADDRESS:8080.
Componenti Ingress
Ecco alcuni dei componenti del cluster correlati a Ingress:
Il deployment
istio-ingress. Questo è il proxy in entrata. Il proxy Ingress inoltra il traffico ai servizi interni in base alle regole specificate in un oggetto Ingress.Il Servizio
istio-ingress. Questo servizio espone il deploymentistio-ingress.Il deployment
istiod. Questo è il controller Ingress. Il controller Ingress controlla la creazione di oggetti Ingress e configura il proxy Ingress di conseguenza.
Crea una risorsa Ingress
Ecco un manifest per un Ingress:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress
spec:
rules:
- http:
paths:
- path: /greet-the-world
pathType: Exact
backend:
service:
name: hello-service
port:
number: 60000
- path: /greet-kubernetes
pathType: Exact
backend:
service:
name: hello-service
port:
number: 60001
Copia il manifest in un file denominato my-ingress.yaml e crea l'oggetto Ingress:
kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-ingress.yaml
Quando crei un cluster utente, specifichi un valore per loadBalancer.vips.ingressVIP nel file di configurazione del cluster. Questo indirizzo IP è configurato sul bilanciatore del carico del cluster. Quando crei un Ingress,
questo riceve lo stesso VIP come indirizzo IP esterno.
Quando un client invia una richiesta al VIP in entrata del cluster utente, la richiesta viene instradata al bilanciatore del carico. Il bilanciatore del carico utilizza il servizio istio-ingress per inoltrare la richiesta al proxy in entrata, che viene eseguito nel cluster utente. Il proxy in entrata è configurato per inoltrare la richiesta a backend diversi a seconda del percorso nell'URL della richiesta.
Il percorso /greet-the-world
Nel manifest Ingress, puoi vedere una regola che indica che il percorso /greet-the-world è associato a service.name: hello-service e service.port.number: 60000. Ricorda che 60000 è il valore port nella sezione world-port del servizio hello-service.
- name: world-port
port: 60000
protocol: TCP
targetPort: 50000
Il servizio Ingress inoltra la richiesta a clusterIP:50000. La richiesta viene quindi inviata a uno dei pod membri del servizio hello-service. Il container, in quel pod, in ascolto sulla porta 50000 visualizza un messaggio Hello, world!.
Il percorso /greet-kubernetes
Nel manifest Ingress, puoi vedere una regola che indica che il percorso /greet-kubernetes è associato a service.name: hello-service e service.port.number: 60001. Ricorda che 60001 è il valore port nella sezione kubernetes-port del servizio hello-service.
- name: kubernetes-port
port: 60001
protocol: TCP
targetPort: 8080
Il servizio Ingress inoltra la richiesta a clusterIP:8080. La richiesta viene quindi inviata a uno dei pod membri del servizio hello-service. Il container, in quel pod, in ascolto sulla porta 8080, visualizza un messaggio Hello Kubernetes!.
Testa la risorsa Ingress
Testa l'oggetto Ingress utilizzando il percorso /greet-the-world:
curl USER_CLUSTER_INGRESS_VIP/greet-the-world
Sostituisci USER_CLUSTER_INGRESS_VIP con l'indirizzo IP esterno dell'Ingress.
L'output mostra un messaggio Hello, world!:
Hello, world! Version: 2.0.0 Hostname: ...
Testa l'oggetto Ingress utilizzando il percorso /greet-kubernetes:
curl USER_CLUSTER_INGRESS_VIP/greet-kubernetes
L'output mostra un messaggio Hello Kubernetes!:
Hello Kubernetes!
Configura HTTPS per Ingress
Se vuoi accettare richieste HTTPS dai tuoi client, il proxy in entrata deve avere un certificato per poter dimostrare la propria identità ai client. Questo proxy deve avere anche una chiave privata per completare l'handshake HTTPS.
L'esempio seguente utilizza queste entità:
Proxy Ingress: partecipa all'handshake HTTPS, quindi inoltra i pacchetti ai pod membri del servizio
hello-service.Dominio per il servizio
hello-service: altostrat.com in Example Org
Segui questi passaggi:
Crea un certificato radice e una chiave privata. Questo esempio utilizza un'autorità di certificazione radice di
root.ca.example.comin Root CA Example Inc.openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=Root CA Example Inc./CN=root.ca.example.com' -keyout root-ca.key -out root-ca.crt
Crea una richiesta di firma del certificato:
openssl req -out server.csr -newkey rsa:2048 -nodes -keyout server.key -subj "/CN=altostrat.com/O=Example Org"
Crea un certificato di gestione per il proxy Ingress.
openssl x509 -req -days 365 -CA root-ca.crt -CAkey root-ca.key -set_serial 0 -in server.csr -out server.crt
Ora hai creato i seguenti certificati e chiavi:
root-ca.crt: il certificato per la CA radiceroot-ca.key: chiave privata della CA radiceserver.crt: certificato di pubblicazione per il proxy in entrataserver.key: chiave privata per il proxy in entrata
Crea un secret Kubernetes che contiene il certificato e la chiave di gestione.
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG create secret tls example-server-creds --key=server.key --cert=server.crt --namespace gke-system
Il secret risultante è denominato
example-server-creds.
Crea un deployment e un servizio
Se hai creato un deployment e un servizio nella sezione HTTP di questa guida, lasciali invariati. Se non l'hai fatto, creali ora, seguendo i passaggi descritti per HTTP.
Crea una risorsa Ingress
La creazione di un Ingress per HTTPS è simile alla creazione di un Ingress per HTTP, ma la specifica Ingress per HTTPS include una sezione tls che specifica l'host e un Secret. Il hosts nella sezione tls deve corrispondere esplicitamente al host nella sezione rules.
Se il servizio di backend si trova in uno spazio dei nomi separato, devi creare un servizio di tipo ExternalName nello stesso spazio dei nomi dell'oggetto Ingress per instradare il traffico al servizio di backend.
Se in precedenza hai creato un Ingress nella sezione HTTP, eliminalo prima di procedere.
Elimina la risorsa Ingress:
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete ingress my-ingress
Per gestire il traffico per il servizio che hai creato in precedenza, crea una nuova risorsa Ingress con una sezione tls. In questo modo, verrà abilitato il protocollo HTTPS tra i client e il proxy in entrata.
Ecco un manifest per un Ingress:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-ingress-2
spec:
tls:
- hosts:
- altostrat.com
secretName: example-server-creds
rules:
- host: altostrat.com
http:
paths:
- path: /greet-the-world
pathType: Exact
backend:
service:
name: hello-service
port:
number: 60000
- path: /greet-kubernetes
pathType: Exact
backend:
service:
name: hello-service
port:
number: 60001
Salva il manifest in un file denominato my-ingress-2.yaml e crea la risorsa Ingress:
kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-ingress-2.yaml
Conferma tramite test.
Testa il percorso
/greet-the-world:curl -v --resolve altostrat.com:443:USER_CLUSTER_INGRESS_VIP https://altostrat.com/greet-the-world --cacert root-ca.crt
Output:
Hello, world! Version: 2.0.0 Hostname: hello-deployment-5ff7f68854-wqzp7
Testa il percorso
/greet-kubernetes:curl -v --resolve altostrat.com:443:USER_CLUSTER_INGRESS_VIP https://altostrat.com/greet-kubernetes --cacert root-ca.crt
Output:
Hello Kubernetes!
Pulizia
Elimina l'Ingress:
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete ingress INGRESS_NAME
Sostituisci INGRESS_NAME con il nome dell'Ingress, ad esempio my-ingress o my-ingress-2.
Elimina il servizio:
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete service hello-service
Elimina il deployment:
kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete deployment hello-deployment