Questa pagina è stata tradotta dall'API Cloud Translation.

Creazione di un Servizio e un Ingress

Questo documento mostra come creare un oggetto Ingress Kubernetes 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

Per creare un deployment:

Crea un manifest di 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 del 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 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.
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 deployment, crea un servizio:

Crea un manifest del servizio che esponga 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.
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 del servizio, consulta ServiceSpec nella documentazione di Kubernetes.

Questi sono 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 a clusterIP su port (ad esempio 10.96.14.249:60000). Il controller Ingress inoltra la richiesta a un pod membro su targetPort (ad esempio POD_IP_ADDRESS:50000, dove POD_IP_ADDRESS è l'indirizzo IP di un pod membro).
- Utilizzo di kubernetes-port: un client in esecuzione su uno dei nodi del cluster invia una richiesta a clusterIP su port (10.96.14.249:60001). Il controller Ingress inoltra la richiesta a un pod membro su targetPort (POD_IP_ADDRESS:8080).

Componenti Ingress

Ecco alcuni componenti del cluster correlati all'ingresso:

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 deployment istio-ingress.
Il deployment istiod. Questo è il controller Ingress. Il controller Ingress monitora la creazione di oggetti Ingress e configura il proxy Ingress di conseguenza.

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 una risorsa Ingress

Per creare un Ingress:

Crea un manifest 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.

Crea la risorsa 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 Ingress viene assegnato 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 inoltra la richiesta a backend diversi 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 servizio hello-service.

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

Il servizio in entrata 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 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 di 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 viene quindi inviata a uno dei pod membri del servizio hello-service. Il container in quel pod, in ascolto sulla porta 8080, mostra un messaggio Hello Kubernetes!.

Testa l'ingresso

Testa l'ingresso utilizzando il percorso /greet-the-world:
```
curl CLUSTER_INGRESS_VIP/greet-the-world
```
Sostituisci CLUSTER_INGRESS_VIP con l'indirizzo IP esterno dell'ingresso.

L'output mostra un messaggio Hello, world!:
```
Hello, world!
Version: 2.0.0
Hostname: ...
```
Testa l'ingresso 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à Ingress inclusa in Google Distributed Cloud supporta solo le funzionalità Ingress. Puoi scegliere di eseguire l'integrazione con Istio o Cloud Service Mesh. Questi prodotti offrono ulteriori vantaggi di una rete mesh di servizi completamente funzionale, come Transport Layer Security (mTLS) reciproca, la possibilità di gestire l'autenticazione tra i servizi e l'osservabilità dei carichi di lavoro. Se esegui l'integrazione con Istio o Cloud Service Mesh, ti consigliamo di disattivare la funzionalità Ingress integrata.

Puoi attivare o disattivare Ingress in bundle con il campo spec.clusterNetwork.bundledIngress nel file di configurazione del cluster. Questo campo è disponibile solo per i cluster versione 1.13.0 e successive. Il campo bundledIngress ha come valore predefinito true e non è presente nel file di configurazione del cluster generato. Questo campo è modificabile e può essere modificato quando crei o aggiorni un cluster versione 1.13.0 o successive.

Per disattivare la funzionalità Ingress in bundle, aggiungi il campo bundledIngress alla sezione clusterNetwork del file di configurazione del cluster e imposta il relativo valore su false, come mostrato nell'esempio seguente:

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 le richieste HTTPS dai tuoi client, il proxy Ingress deve avere un certificato per poter dimostrare la propria identità ai tuoi client. Questo proxy deve anche avere una chiave privata per completare l'handshake HTTPS.

Il seguente esempio utilizza queste entità:

Proxy Ingress: partecipa all'handshake HTTPS e poi 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 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

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 servizio 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: Certificato per la CA radice
- root-ca.key: Chiave privata per la CA radice
- server.crt: Certificato di servizio per il proxy in entrata
- server.key: Chiave privata per il proxy in entrata
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.

Crea un deployment e un servizio

Se hai creato un deployment e un servizio nella parte HTTP di questa guida, lasciali in posizione. In caso contrario, creali ora seguendo i passaggi descritti per HTTP.

Crea una risorsa Ingress

La creazione di una risorsa Ingress per HTTPS è simile alla creazione di una risorsa 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 di Ingress per instradare il traffico al servizio di backend.

I passaggi generali per creare una risorsa Ingress per HTTPS o HTTP sono gli stessi, ad eccezione di ciò che configuri nel file manifest:

Se in precedenza hai creato un Ingress nella sezione HTTP di questo documento, eliminalo prima di procedere.
```
kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress
```

Per gestire il traffico per il servizio che hai creato in precedenza, crea un nuovo manifest Ingress con una sezione tls:

La configurazione tls abilita HTTPS tra i client e il proxy in entrata.

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'ingresso:
```
kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f my-ingress-2.yaml
```

Verifica che l'ingresso sia stato creato e funzioni correttamente eseguendo i seguenti 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 tuoi carichi di lavoro all'esterno del cluster. Per istruzioni ed esempi per la creazione di un servizio di tipo LoadBalancer, vedi Creare un servizio di tipo LoadBalancer in Eseguire il deployment di un'applicazione.

Pulizia

Elimina il tuo Ingress:
```
kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME
```
Sostituisci INGRESS_NAME con il nome dell'ingresso, ad esempio my-ingress o my-ingress-2.

Elimina 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

Creazione di un Servizio e un Ingress

Creazione di un deployment

Esporre il deployment con un servizio

Componenti Ingress

Crea una risorsa Ingress

Il percorso /greet-the-world

Il percorso /greet-kubernetes

Testa l'ingresso

Disattiva Ingress in bundle

Configurare HTTPS per Ingress

Crea un deployment e un servizio

Crea una risorsa Ingress

Crea un servizio LoadBalancer

Pulizia

Il percorso `/greet-the-world`

Il percorso `/greet-kubernetes`