Configurer la terminaison TLS dans la passerelle d'entrée

Présentation

Cette page explique comment configurer une terminaison TLS dans la passerelle d'entrée dans Cloud Service Mesh pour gérer le trafic HTTPS externe vers vos services. Vous allez apprendre à configurer la passerelle pour la communication sécurisée à l'aide de TLS, ce qui permet d'accéder de manière chiffrée à vos applications. Ce processus exploite les fonctionnalités de Cloud Service Mesh pour exposer des services, par exemple de manière sécurisée.

Avant de commencer

Pour suivre la procédure décrite dans ce document, vous avez besoin des ressources suivantes :

  • Un cluster Kubernetes sur lequel Cloud Service Mesh est installé.

Configurer votre environnement

Exécutez les commandes suivantes à partir d'un poste de travail pouvant accéder au cluster que vous souhaitez utiliser. Assurez-vous que l'outil kubectl est configuré pour utiliser le contexte spécifique au cluster.

  1. Définissez les variables d'environnement.

    export ASM_INGRESSGATEWAY_NAMESPACE=asm-ingressgateway
    export ASM_INGRESSGATEWAY_DEPLOYMENT_NAME=asm-ingressgateway
    export ASM_INGRESSGATEWAY_SERVICE_NAME=asm-ingressgateway
    
  2. L'application foo déployée dans votre cluster. Installez-le avec:

    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. Générer des certificats et des clés

Pour sécuriser votre passerelle d'entrée, vous aurez besoin de certificats et de clés TLS. Vous pouvez utiliser n'importe quel outil de génération de certificats ou suivre ces étapes à l'aide d'openssl pour créer les identifiants nécessaires.

  • Créer un certificat et une clé d'autorité de certification racine

    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
    
  • Générer un certificat et une clé pour l'entrée

    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
    

Configurer une passerelle d'entrée TLS

Avant de suivre les instructions de cette section, vous devez déterminer l'implémentation de votre plan de contrôle. Pour ce faire, suivez les instructions de la section Identifier l'implémentation du plan de contrôle.

  1. Créez l'espace de noms Cet espace de noms est utilisé pour déployer la passerelle d'entrée.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
    
  2. Appliquez le libellé d'injection par défaut à l'espace de noms:

    kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
        istio.io/rev- istio-injection=enabled --overwrite
    
  3. Appliquez le fichier manifeste de passerelle d'entrée.

    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
    

    Résultat attendu :

    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. Stockez les identifiants TLS dans 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. Définissez la passerelle d'entrée: créez une ressource Gateway pour gérer le trafic HTTPS sur le port 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. Routage du trafic vers le service foo: définissez un VirtualService pour acheminer le trafic vers le déploiement 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. Configurer l'équilibreur de charge externe pour qu'il se connecte à la passerelle d'entrée du cluster

  8. Testez la connexion sécurisée: utilisez curl pour vérifier la configuration:

    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"
    

Remplacez EXTERNAL_LB_IP_ADDRESS par l'adresse IP de l'équilibreur de charge externe.

Le résultat ressemble à ce qui suit :

    {
      "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"
    }

Étape suivante