Creazione di un Servizio e un Ingress

Questo documento mostra come creare un cluster Kubernetes In entrata in un cluster utente, ibrido o autonomo per Google Distributed Cloud. Un traffico in entrata è associato a uno o più servizi, ognuno dei quali è associato a un insieme 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, questi sono 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 env specificano che i container hello-app sono in ascolto su TCP sulla porta 50000 e i container node-hello sono in ascolto sulla porta TCP 8080. Per hello-app, puoi vedere l'effetto della variabile di ambiente PORT esaminando i 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 kubeconfig per il tuo cluster.

Esposizione del deployment con un servizio

a fornire ai client un modo stabile per inviare richieste ai pod per il deployment, creare un Service.

Ecco un manifest per un servizio che espone il tuo deployment ai client all'interno nel tuo 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 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: una denominata world-port e l'altra denominata kubernetes-port. Per ulteriori informazioni sui campi Service, consulta ServiceSpec nella documentazione di Kubernetes.

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

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

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

Componenti in entrata

Ecco alcuni dei componenti del cluster correlati al traffico in entrata:

  • Il deployment istio-ingress. Questo è il proxy in entrata. Il traffico in entrata inoltra il traffico ai servizi interni in base alle regole specificate in un oggetto Ingress.

  • Il servizio istio-ingress. Questo servizio espone l'oggetto istio-ingress per il deployment.

  • Il deployment istiod. Si tratta del controller in entrata. Il traffico in entrata controlla la creazione di In entrata e configura il proxy in entrata di conseguenza.

Tutti questi componenti in-cluster Istio sono installati nell'gke-system nello spazio dei nomi. Questo spazio dei nomi non è in conflitto con un mesh di servizi Istio/Cloud completo dell'installazione.

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 il In entrata:

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

Quando crei un cluster utente, specifichi un valore per loadbalancer.ingressVIP nel file di configurazione del cluster. Questo indirizzo IP è configurate sul bilanciatore del carico del cluster. Quando crei una risorsa Ingress, riceve lo stesso VIP del suo indirizzo IP esterno.

Quando un client invia una richiesta al VIP in entrata del cluster utente, la richiesta viene instradato al bilanciatore del carico. Il bilanciatore del carico utilizza il servizio istio-ingress per inoltrare la richiesta al proxy in entrata, eseguito nel cluster utente. La Il proxy in entrata è configurato per inoltrare la richiesta a backend diversi a seconda nel percorso dell'URL della richiesta.

Percorso /greet-the-world

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

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

Il servizio in entrata inoltra la richiesta a clusterIP:50000. La richiesta quindi va a uno dei pod membri del servizio hello-service. Il container, in quel pod, in ascolto sulla porta 50000 viene visualizzato un messaggio Hello World!.

Percorso /greet-kubernetes

Nel manifest Ingress, puoi vedere una regola che indica 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 in entrata inoltra la richiesta a clusterIP: 8080. La richiesta quindi va a uno dei pod membri del servizio hello-service. Il container, in quel pod, in ascolto sulla porta 8080 viene visualizzato un messaggio Hello Kubernetes!.

Testa Ingress

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

curl CLUSTER_INGRESS_VIP/greet-the-world

Sostituisci CLUSTER_INGRESS_VIP con l'indirizzo IP esterno di la risorsa Ingress.

L'output mostra un messaggio Hello, world!:

Hello, world!
Version: 2.0.0
Hostname: ...

Testa la risorsa 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

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

Puoi attivare o disattivare il traffico Ingress in bundle con il Campo spec.clusterNetwork.bundledIngress nel file di configurazione del cluster. Questo campo è disponibile solo per i cluster della versione 1.13.0 e successive. La Il campo bundledIngress è impostato su true per impostazione predefinita e non è presente nella colonna generata di configurazione del cluster. Questo campo è modificabile e può essere modificato crea o aggiorna un cluster alla versione 1.13.0 o successiva. Puoi anche specificare 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 configuri per disabilitare la funzionalità Ingress in bundle:

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

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 clienti. Questo proxy e disporre di una chiave privata per completare l'handshake HTTPS.

L'esempio seguente utilizza queste entità:

  • Proxy in entrata: partecipa all'handshake HTTPS e 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 una radice autorità di certificazione di root.ca.example.com nell'organizzazione di esempio della CA radice.

    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 servizio per il proxy in entrata.

    openssl x509 -req -days 365 -CA root-ca.crt -CAkey root-ca.key -set_serial 0 \
    -in server.csr -out server.crt

    A questo punto hai creato i certificati e le chiavi seguenti:

    • root-ca.crt: certificato per la CA radice
    • root-ca.key: chiave privata per la CA principale
    • server.crt: certificato di pubblicazione per il proxy in entrata
    • server.key: chiave privata per il proxy in entrata

  4. Creare un secret Kubernetes contenente il certificato e la chiave di gestione.

    kubectl 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 parte HTTP di questa guida, e lasciarli invariati. Se non l'hai fatto, creali ora seguendo i passaggi descritti per HTTP.

Crea una risorsa Ingress

Se in precedenza hai creato una risorsa Ingress nella parte HTTP, eliminala. prima di procedere.

Elimina l'oggetto Ingress:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress

Per gestire il traffico per il servizio che hai creato in precedenza, crea un nuovo Ingres con una sezione tls. Questa operazione attiverà HTTPS tra i client e 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 l'oggetto Ingress:

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

Conferma 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 tuo cluster. Per istruzioni e un esempio per la creazione di un servizio di tipo LoadBalancer, vedi Crea un servizio di tipo LoadBalancer in "Eseguire il deployment di un'applicazione".

esegui la pulizia

Elimina il tuo Ingress:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME

Sostituisci INGRESS_NAME con il nome di del traffico in entrata, ad esempio my-ingress o my-ingress-2.

Elimina il tuo servizio:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service

Elimina il tuo deployment:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment

Elimina il servizio LoadBalancer:

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