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.
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
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
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.
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}
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
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
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
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
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
Configurer l'équilibreur de charge externe pour qu'il se connecte à la passerelle d'entrée du cluster
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
- Apprenez-en plus sur l'installation et la mise à niveau des passerelles.