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. Per un'introduzione più di base su come configurare i gateway, consulta la guida ai gateway. Scopri 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 i servizi 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. Per informazioni dettagliate su come installare Cloud Service Mesh, consulta la guida all'installazione.

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 CSM_INGRESSGATEWAY_NAMESPACE=CSM_INGRESSGATEWAY_NAMESPACE
export CSM_INGRESSGATEWAY_DEPLOYMENT_NAME=CSM_INGRESSGATEWAY_DEPLOYMENT_NAME
export CSM_INGRESSGATEWAY_SERVICE_NAME=CSM_INGRESSGATEWAY_SERVICE_NAME

  2. Esegui il deployment dell'applicazione foo nel cluster. Installalo con il seguente file yaml:

    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. Genera 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 una chiave e un certificato 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

I passaggi riportati di seguito descrivono come configurare un gateway di ingresso TLS.

Memorizza il certificato TLS

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

    kubectl create namespace ${CSM_INGRESSGATEWAY_NAMESPACE}

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

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

  3. Memorizza le credenziali TLS in un secret Kubernetes:

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

Applica il certificato TLS al gateway

Esistono due modi per fare in modo che il gateway utilizzi il certificato TLS appena creato.

Deployment con credenziali montate (opzione preferita)

  1. Copia il manifest del gateway di ingresso predefinito in un file locale.

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/ingress-gateway-external-lb/ingress-gateway.yaml > ingress-gateway.yaml

  2. Modifica la specifica di deployment in ingress-gateway.yaml per montare la credenziale segreta TLS.

    apiVersion: apps/v1
kind: Deployment
...
spec:
  ...
    spec:
        ...
        volumeMounts:
        - name: foo-credential # Add new volume mount specifying mount path.
          mountPath: /etc/secrets/foo-credential 
          readOnly: true
      volumes:
      - name: foo-credential # Point volume mount to the Kubernetes secret holding the TLS certificate and keys.
        secret:
          secretName: foo-credential

    Poi crea le risorse relative al gateway di ingresso.

    kubectl --namespace ${CSM_INGRESSGATEWAY_NAMESPACE} apply --filename ingress-gateway.yaml

  3. Definisci il gateway in entrata.

    Crea una risorsa Gateway per gestire il traffico HTTPS sulla porta 443 che fa riferimento ai secret montati:

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

Deployment senza credenziali montate

  1. Applica il file manifest del gateway di ingresso.

    kubectl --namespace ${CSM_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

  2. Definisci il gateway in entrata.

    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: ${CSM_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

Testare il traffico

  1. Indirizza il traffico al servizio foo.

    Definisci un VirtualService per indirizzare il traffico all'implementazione foo:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: foo-routing
  namespace: ${CSM_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

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

  3. Testa la connessione sicura.

    Utilizza il seguente comando 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