Creazione di un Servizio e un Ingress

Questo documento mostra come creare un oggetto Kubernetes Ingress in un cluster utente, ibrido o autonomo per Google Distributed Cloud. Un Ingress è associato a uno o più servizi, ciascuno dei quali è associato a un insieme di pod.

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, di seguito sono riportati i punti importanti da comprendere in merito al file manifest di Deployment:

• Ogni pod che appartiene al deployment ha l'etichetta greeting: hello.

• Ogni pod ha due container.

• I campi env specificano che i container hello-app ascoltano sulla porta TCP 50000 e i container node-hello sulla porta TCP 8080. Per hello-app, puoi vedere l'effetto della variabile di ambiente PORT esaminando il codice sorgente.

Copia il manifest in un file denominato hello-deployment.yaml e crea il deployment:

kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-deployment.yaml

Sostituisci CLUSTER_KUBECONFIG con il nome del file kubeconfig per il tuo cluster.

Esporre 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 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 CLUSTER_KUBECONFIG -f hello-service.yaml

Sostituisci CLUSTER_KUBECONFIG con il nome del file kubeconfig per il tuo cluster.

Visualizza il servizio:

kubectl --kubeconfig 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 ServicePort: uno denominato world-port e uno denominato kubernetes-port. Per ulteriori informazioni sui campi Service, consulta ServiceSpec nella documentazione di Kubernetes.

Di seguito sono riportati i modi in cui un cliente può chiamare il servizio:

• Utilizzo di world-port: un client in esecuzione su uno dei nodi del cluster invia una richiesta al clusterIP su port. In questo esempio, 10.96.14.249:60000. La richiesta viene inoltrata a un pod membro il giorno targetPort. In questo esempio, POD_IP_ADDRESS:50000.

• Utilizzo di kubernetes-port: un client in esecuzione su uno dei nodi del cluster invia una richiesta al clusterIP su port. In questo esempio, 10.96.14.249:60001. La richiesta viene inoltrata a un pod membro il giorno targetPort. In questo esempio, POD_IP_ADDRESS:8080.

Componenti di Ingress

Di seguito sono riportati alcuni dei componenti del cluster relativi all'ingresso:

Nota: i componenti Istio preinstallati su Google Distributed Cloud supportano solo l'ingresso. Questi componenti non sono progettati per fornire funzionalità di mesh di servizi generali. Per informazioni sulla configurazione di un mesh di servizi completamente funzionale, consulta Configurazione nella documentazione di Istio o Configurare un mesh multi-cluster al di fuori di Google Cloud nella documentazione di Cloud Service Mesh.

• Il deployment istio-ingress. Si tratta del proxy di ingresso. Il proxy di ingresso inoltra il traffico ai servizi interni in base alle regole specificate in un oggetto Ingress.

• Il Servizio istio-ingress. Questo servizio espone il deployment istio-ingress.

• Il deployment istiod. Questo è il controller di ingresso. Il controller di ingressi monitora la creazione di oggetti Ingress e configura di conseguenza il proxy di ingresso.

Tutti questi componenti Istio in-cluster sono installati nello spazio dei nomi gke-system. Questo spazio dei nomi non è in conflitto con un'installazione completa di Istio/Cloud Service Mesh.

Crea un 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 il servizio Ingress:

kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress.yaml

Quando crei un cluster utente, specifica un valore per loadbalancer.ingressVIP nel file di configurazione del cluster. Questo indirizzo IP è configurato sul bilanciatore del carico del cluster. Quando crei un Ingress, a questo viene assegnato lo stesso VIP come indirizzo IP esterno.

Quando un client invia una richiesta all'indirizzo VIP di ingresso 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 di ingresso, che viene eseguito nel cluster di utenti. Il proxy di ingresso è configurato per inoltrare la richiesta a diversi backend a seconda del percorso nell'URL della richiesta.

Il percorso /greet-the-world

Nel manifest di Ingress, puoi vedere una regola che indica che il percorso /greet-the-world è associato a serviceName: hello-service e servicePort: 60000. Ricorda che 60000 è il valore port nella sezione world-port del tuo servizio hello-service.

- name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000

Il servizio di ingresso inoltra la richiesta a clusterIP:50000. La richiesta viene poi inviata a uno dei pod membri del servizio hello-service. Il container nel pod in ascolto sulla porta 50000 mostra un messaggio Hello World!.

Il percorso /greet-kubernetes

Nel manifest di Ingress, puoi vedere una regola che indica che il percorso /greet-kubernetes è associato a serviceName: hello-service e servicePort: 60001. Ricorda che 60001 è il valore port nella sezione kubernetes-port del tuo servizio hello-service.

- name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080

Il servizio di ingresso inoltra la richiesta a clusterIP: 8080. La richiesta viene poi inviata a uno dei pod membri del servizio hello-service. Il container, nel pod, in ascolto sulla porta 8080, mostra un messaggio Hello Kubernetes!.

Testa Ingress

Testa Ingress utilizzando il percorso /greet-the-world:

curl CLUSTER_INGRESS_VIP/greet-the-world

Sostituisci 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 Ingress utilizzando il percorso /greet-kubernetes:

curl CLUSTER_INGRESS_VIP/greet-kubernetes

L'output mostra un messaggio Hello, Kubernetes!:

Hello Kubernetes!

Disattiva Ingress in bundle

La funzionalità di importazione inclusa in Google Distributed Cloud supporta solo la funzionalità di importazione. Puoi scegliere di eseguire l'integrazione con Istio o Cloud Service Mesh. Questi prodotti offrono i vantaggi aggiuntivi di una rete mesh di servizi completamente funzionale, come TLS reciproco (mTLS), la possibilità di gestire l'autenticazione tra i servizi e l'osservabilità del carico di lavoro. Se esegui l'integrazione con Istio o Cloud Service Mesh, ti consigliamo di disattivare la funzionalità Ingress inclusa.

Puoi attivare o disattivare Ingress incluso con il spec.clusterNetwork.bundledIngress campo nel file di configurazione del cluster. Questo campo è disponibile solo per i cluster della versione 1.13.0 e successive. Il valore predefinito del campo bundledIngress è true e non è presente nel file di configurazione del cluster generato. Questo campo è mutabile e può essere modificato quando crei o aggiorni un cluster della versione 1.13.0 o successive. Puoi anche specificare questo campo quando esegui l'upgrade di un cluster alla versione 1.13.0 o successiva.

Il seguente file di configurazione del cluster di esempio mostra come configurare il cluster per disattivare la funzionalità Ingress inclusa:

apiVersion: v1
kind: Namespace
metadata:
  name: cluster-hybrid-basic
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: hybrid-basic
  namespace: cluster-hybrid-basic
spec:
  type: hybrid
  profile: default
  anthosBareMetalVersion: 1.13.0
  gkeConnect:
    projectID: project-fleet
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: 10.200.0.2
  clusterNetwork:
    bundledIngress: false
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
...

Configurare HTTPS per Ingress

Se vuoi accettare richieste HTTPS dai tuoi client, il proxy di ingresso deve avere un certificato per dimostrare la propria identità ai client. Questo proxy deve anche avere una chiave privata per completare l'handshake HTTPS.

L'esempio seguente utilizza queste entità:

• Proxy di ingresso: partecipa all'handshake HTTPS e poi inoltra i pacchetti ai pod membri del servizio hello-service.

• Dominio per il servizio hello-service: altostrat.com nell'organizzazione di esempio

Segui questi passaggi:

1. Crea un certificato radice e una chiave privata. Questo esempio utilizza un'autorità di certificazione radice di root.ca.example.com in Root CA Example Org.

   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

2. 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"

3. Crea un certificato di pubblicazione per il proxy di ingresso.

   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: certificato per la CA radice
   • root-ca.key: chiave privata per la CA radice
   • server.crt: certificato di servizio per il proxy di ingresso
   • server.key: chiave privata per il proxy di ingresso

4. Crea un secret Kubernetes che contenga il certificato e la chiave di servizio.

   kubectl create secret tls example-server-creds --key=server.key --cert=server.crt \
       --namespace gke-system

   Il secret risultante si chiama example-server-creds.

   Nota: i secret TLS devono essere definiti nello spazio dei nomi gke-system.

Creare un deployment e un servizio

Se hai creato un deployment e un servizio nella parte HTTP di questa guida, non modificarli. In caso contrario, creane ora seguendo i passaggi descritti per HTTP.

Crea un Ingress

Se in precedenza hai creato un Ingress nella parte HTTP, eliminalo prima di procedere.

Elimina l'elemento Ingress:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress

Per gestire il traffico per il servizio creato in precedenza, crea un nuovo Ingres con una sezione tls. In questo modo verrà attivato HTTPS tra i client e il proxy di ingresso.

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 l'Ingress:

kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress-2.yaml

Conferma con il test.

• Testa il percorso /greet-the-world:

  curl -v --resolve altostrat.com:443: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:CLUSTER_INGRESS_VIP \
      https://altostrat.com/greet-kubernetes --cacert root-ca.crt

  Output:

  Hello Kubernetes!
  

Crea un servizio LoadBalancer

Un servizio di tipo LoadBalancer è un altro modo per esporre i carichi di lavoro all'esterno del cluster. Per istruzioni e un esempio di creazione di un servizio di tipo LoadBalancer, consulta Creare un servizio di tipo LoadBalancer in Eseguire il deployment di un'applicazione.

Pulizia

Elimina l'Ingress:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME

Sostituisci INGRESS_NAME con il nome dell'Ingress, ad esempio my-ingress o my-ingress-2.

Eliminare il servizio:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service

Elimina il deployment:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment

Elimina il servizio LoadBalancer:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service service-does-not-use-nodeports