Configurare la terminazione TLS nel gateway in entrata

Panoramica

Questa pagina mostra come configurare una terminazione TLS nel gateway di ingresso in Cloud Service Mesh per gestire il traffico HTTPS esterno verso i tuoi servizi. Scoprirai come configurare il gateway per la comunicazione sicura utilizzando TLS, attivando l'accesso criptato alle tue applicazioni. Questo processo sfrutta le funzionalità di Cloud Service Mesh per esporre servizi come in modo sicuro.

Prima di iniziare

Per completare i passaggi descritti in questo documento, sono necessarie le seguenti risorse:

  • Un cluster Kubernetes con Cloud Service Mesh installato.

Configura l'ambiente

Esegui i seguenti comandi da una workstation che può accedere al cluster che intendi utilizzare. Assicurati che lo strumento kubectl sia configurato per utilizzare il contesto del cluster specifico del tuo cluster.

  1. Imposta le variabili di ambiente.

    export ASM_INGRESSGATEWAY_NAMESPACE=asm-ingressgateway
export ASM_INGRESSGATEWAY_DEPLOYMENT_NAME=asm-ingressgateway
export ASM_INGRESSGATEWAY_SERVICE_NAME=asm-ingressgateway

  2. L'applicazione foo di cui è stato eseguito il deployment nel cluster. Installalo con:

    apiVersion: v1
kind: Service
metadata:
  name: foo
  namespace: foo
spec:
  selector:
    app: test-backend
  ports:
  - port: 8080
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: foo
  namespace: foo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test-backend
  template:
    metadata:
      labels:
        app: test-backend
    spec:
      containers:
      - name: whereami
        image: gcr.io/google-samples/whereami:v1.2.23
        ports:
        - containerPort: 8080
EOF

  3. Generare certificati e chiavi

Per proteggere il gateway di ingresso, avrai bisogno di certificati e chiavi TLS. Puoi utilizzare qualsiasi strumento di generazione di certificati o seguire questa procedura utilizzando openssl per creare le credenziali necessarie.

  • Crea un certificato e una chiave della CA radice

    mkdir example_certs
openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=Example Corp/CN=example.com' \
  -keyout example.com.key -out example.com.crt

  • Genera un certificato e una chiave per l'ingress

    openssl req -out foo.example.com.csr -newkey rsa:2048 -nodes \
  -keyout foo.example.com.key -subj "/CN=foo.example.com/O=Foo Org"

openssl x509 -req -sha256 -days 365 -CA example.com.crt \
  -CAkey example.com.key -set_serial 0 \
  -in foo.example.com.csr -out foo.example.com.crt

Configurare un gateway di ingresso TLS

Prima di completare le istruzioni in questa sezione, devi determinare l'implementazione del tuo control plane. Per farlo, segui le istruzioni riportate in Identificare l'implementazione del control plane.

  1. Crea lo spazio dei nomi. Questo spazio dei nomi viene utilizzato per eseguire il deployment del gateway di ingresso.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}

  2. Applica l'etichetta di inserimento predefinita allo spazio dei nomi:

    kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
    istio.io/rev- istio-injection=enabled --overwrite

  3. Applica il file manifest del gateway di ingresso.

    kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} apply --filename https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/ingress-gateway-external-lb/ingress-gateway.yaml

    Risultato previsto:

    serviceaccount/asm-ingressgateway created
role.rbac.authorization.k8s.io/asm-ingressgateway created
rolebinding.rbac.authorization.k8s.io/asm-ingressgateway created
deployment.apps/asm-ingressgateway created
service/asm-ingressgateway created
poddisruptionbudget.policy/asm-ingressgateway created
horizontalpodautoscaler.autoscaling/asm-ingressgateway created

  4. Memorizza le credenziali TLS in un secret Kubernetes:

    kubectl create -n ${ASM_INGRESSGATEWAY_NAMESPACE} secret tls foo-credential \
  --key=example_certs/foo.example.com.key \
  --cert=example_certs/foo.example.com.crt

  5. Definisci il gateway di ingresso: crea una risorsa Gateway per gestire il traffico HTTPS sulla porta 443:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: Gateway
metadata:
  name: secure-gateway
  namespace: ${ASM_INGRESSGATEWAY_NAMESPACE}
spec:
  selector:
    app: asm-ingressgateway
    istio: ingressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: foo-credential
    hosts:
    - "foo.example.com"
EOF

  6. Indirizza il traffico al servizio foo: definisci un VirtualService per indirizzare il traffico al deployment di foo:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: foo-routing
  namespace: ${ASM_INGRESSGATEWAY_NAMESPACE}
spec:
  hosts:
  - "foo.example.com"
  gateways:
  - secure-gateway
  http:
  - match:
    - uri:
        prefix: /status
    - uri:
        prefix: /delay
    route:
    - destination:
        host: foo
        port:
          number: 8080
EOF

  7. Configura il bilanciatore del carico esterno per connetterti al gateway di ingresso dal cluster

  8. Testa la connessione sicura: utilizza curl per verificare la configurazione:

    export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
curl -v -H "Host: foo.example.com" --resolve "foo.example.com:443:$EXTERNAL_LB_IP_ADDRESS" \
  --cacert example_certs/example.com.crt "https://foo.example.com:443/ping"

Sostituisci EXTERNAL_LB_IP_ADDRESS con l'IP del bilanciatore del carico esterno.

L'output è simile al seguente:

    {
      "cluster_name": "gke-us",
      "host_header": "34.120.175.141",
      "pod_name": "whereami-deployment-954cbf78-mtlpf",
      "pod_name_emoji": "😎",
      "project_id": "my-project",
      "timestamp": "2021-11-29T17:01:59",
      "zone": "us-central1-b"
    }

Passaggi successivi