Configurer mTLS pour le backend

Cette page fournit des instructions pour configurer le protocole mTLS de backend à l'aide de certificats autogérés pour les équilibreurs de charge d'application externes globaux.

La procédure de configuration du mTLS backend est semblable à celle du TLS backend authentifié, à l'exception que vous devez également créer un certificat pour l'équilibreur de charge. Ce certificat, également appelé certificat client, est associé à la ressource de configuration de l'authentification du backend. L'équilibreur de charge utilise ce certificat client pour s'authentifier auprès des backends.

Pour configurer le mTLS backend, procédez comme suit:

  • Créez une ressource de configuration de confiance composée de certificats racine et intermédiaires.
  • Créez un certificat client, puis importez-le dans le Gestionnaire de certificats.
  • Créez une ressource de configuration d'authentification de backend qui fait référence à la configuration de confiance et au certificat client.
  • Associez la ressource de configuration de l'authentification de backend au service de backend de l'équilibreur de charge.

Avant de commencer

Autorisations

Cette section liste les autorisations requises pour configurer l'authentification mTLS du backend.
Opération Autorisation
Créer une configuration de confiance certificatemanager.trustconfigs.create sur le projet Google Cloud cible
Créer un certificat client certificatemanager.certs.create sur le projet Google Cloud cible
Créer une ressource de configuration d'authentification de backend
  • certificatemanager.certs.use sur le certificat cible
  • certificatemanager.trustconfigs.use sur la configuration de confiance cible
  • networksecurity.backendauthenticationconfigs.create sur le projet Google Cloud cible
    		•
    Associer la ressource de configuration de l'authentification de backend au service de backend de l'équilibreur de charge
  • compute.backendservice.update sur le service de backend cible
  • networksecurity.backendauthenticationconfigs.use sur la ressource de configuration d'authentification de backend cible
    		•

    Vue d'ensemble de la configuration

    Les sections suivantes décrivent les étapes à suivre pour configurer le mTLS backend en fonction de l'architecture illustrée dans le schéma suivant:

    Composants du mTLS backend.
    Composants mTLS du backend (cliquez pour agrandir).

    Créer les certificats racine et intermédiaires

    Cette section utilise la bibliothèque OpenSSL pour créer le certificat racine (ancre de confiance) et le certificat intermédiaire.

    Un certificat racine se trouve au sommet de la chaîne de certificats. Un certificat intermédiaire fait partie de la chaîne de confiance qui remonte au certificat racine. Le certificat intermédiaire est signé de manière cryptographique par le certificat racine. Lorsque l'équilibreur de charge reçoit un certificat de serveur, il le valide en établissant une chaîne de confiance à partir du certificat de serveur jusqu'à l'ancre de confiance configurée.

    Utilisez les commandes suivantes pour créer les certificats racine et intermédiaires.

    1. Créez un fichier de configuration OpenSSL.

      Dans l'exemple suivant, le fichier de configuration (example.cnf) contient la section [ca_exts], qui spécifie les extensions X.509 qui marquent le certificat comme adapté à une autorité de certification. Pour en savoir plus sur les exigences concernant les certificats racine et intermédiaires, consultez la section Exigences concernant les certificats.

      cat > example.cnf << EOF
[req]
distinguished_name = empty_distinguished_name

[empty_distinguished_name]
# Kept empty to allow setting via -subj command-line argument.

[ca_exts]
basicConstraints=critical,CA:TRUE
keyUsage=keyCertSign
extendedKeyUsage=serverAuth

EOF

    2. Créez un certificat racine X.509 autosigné (root.cert). Le certificat racine est autosigné avec sa propre clé privée (root.key).

      openssl req -x509 \
    -new -sha256 -newkey rsa:2048 -nodes \
    -days 3650 -subj '/CN=root' \
    -config example.cnf \
    -extensions ca_exts \
    -keyout root.key -out root.cert

    3. Créez la requête de signature de certificat (CSR) int.req pour le certificat intermédiaire.

      openssl req -new \
    -sha256 -newkey rsa:2048 -nodes \
    -subj '/CN=int' \
    -config example.cnf \
    -extensions ca_exts \
    -keyout int.key -out int.req

    4. Signez la requête de signature de certificat pour créer le certificat intermédiaire X.509 (int.cert). La requête de signature de certificat est signée à l'aide du certificat racine.

      openssl x509 -req \
    -CAkey root.key -CA root.cert \
    -set_serial 1 \
    -days 3650 \
    -extfile example.cnf \
    -extensions ca_exts \
    -in int.req -out int.cert

    Mettre en forme les certificats

    Pour inclure de nouveaux certificats ou des certificats existants dans un truststore, définissez une mise en forme de ces certificats sur une seule ligne et stockez-les dans des variables d'environnement afin qu'ils puissent être référencés par le fichier YAML de configuration de confiance.

    export ROOT_CERT=$(cat root.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

    export INTERMEDIATE_CERT=$(cat int.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

    Créer une ressource de configuration de confiance

    Une configuration de confiance est une ressource qui représente votre configuration d'infrastructure à clé publique (PKI) dans le gestionnaire de certificats.

    Pour créer une ressource de configuration de confiance, procédez comme suit:

    Console

    1. Dans la console Google Cloud, accédez à la page Gestionnaire de certificats.

      Accéder au Gestionnaire de certificats

    2. Dans l'onglet Configurations d'approbation, cliquez sur Ajouter une configuration d'approbation.

    3. Attribuez un nom à la configuration.

    4. Dans Emplacement, sélectionnez Mondial. L'emplacement indique l'emplacement où la ressource de configuration de confiance est stockée. Pour les équilibreurs de charge d'application externes globaux, vous devez créer une ressource de configuration de confiance globale.

    5. Dans la section Truststore (Truststore), cliquez sur Add trust anchor (Ajouter une ancre de confiance) et importez le fichier de certificat encodé au format PEM ou copiez le contenu du certificat.

    6. Cliquez sur Ajouter.

    7. Dans la section Truststore (Truststore), cliquez sur Add intermediate CA (Ajouter une autorité de certification intermédiaire) et importez le fichier de certificat encodé au format PEM ou copiez le contenu du certificat. Cette étape vous permet d'ajouter un autre niveau de confiance entre le certificat racine et votre certificat de serveur.

    8. Cliquez sur Add (Ajouter) pour ajouter l'autorité de certification intermédiaire.

    9. Pour ajouter le certificat à la liste d'autorisation, cliquez sur Ajouter.

    10. Cliquez sur Créer.

    Vérifiez que la nouvelle ressource de configuration de confiance apparaît dans la liste des configurations.

    gcloud

    1. Créez un fichier YAML de configuration de confiance (trust_config.yaml) qui spécifie les paramètres de configuration de confiance. Cet exemple de ressource de configuration de confiance contient un truststore avec une ancre de confiance et un certificat intermédiaire. Cet exemple de ressource de configuration de confiance lit le contenu du certificat à partir des variables d'environnement créées à l'étape précédente, Mettre en forme les certificats.

      cat << EOF > trust_config.yaml
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT_CERT}"
  intermediateCas:
  - pemCertificate: "${INTERMEDIATE_CERT}"
EOF

      Pour créer un truststore avec d'autres ancres de confiance ou d'autres certificats CA intermédiaires, ajoutez des lignes pemCertificate dans la section appropriée.

    2. Pour importer le fichier YAML de configuration de confiance, utilisez la commande gcloud certificate-manager trust-configs import:

      Pour les équilibreurs de charge d'application externes globaux, spécifiez global comme emplacement de stockage de la ressource de configuration de confiance.

      gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME  \
    --source=trust_config.yaml \
    --location=global

      Remplacez les éléments suivants :

      • TRUST_CONFIG_NAME : nom de la ressource de configuration de confiance

    Créer un certificat client

    Dans le mTLS de backend, l'équilibreur de charge agit en tant que client et le backend en tant que serveur.

    Pour activer le mTLS du backend, l'équilibreur de charge doit prouver son identité au backend. Cette authentification est effectuée à l'aide d'un certificat client que l'équilibreur de charge présente au backend. Le serveur backend doit valider le certificat client à l'aide de sa propre chaîne de confiance.

    Lorsqu'il se connecte à un serveur backend, l'équilibreur de charge définit l'indication du nom du serveur (SNI) sur le nom d'hôte spécifié dans la configuration TLS. Le serveur backend sélectionne le certificat SSL/TLS approprié en fonction de cette valeur SNI. L'équilibreur de charge s'attend à ce que la valeur SNI corresponde à un autre nom de l'objet (SAN) listé dans le certificat du serveur backend.

    Les certificats client peuvent être des certificats gérés par une autorité de certification privée via le service d'autorité de certification ou des certificats PKI privés autogérés. Dans cet exemple, le certificat client est délivré à l'aide de certificats autogérés. Cette section utilise la bibliothèque OpenSSL pour créer le certificat de l'autorité de certification racine et le certificat client.

    Pour créer un certificat client, procédez comme suit:

    1. Créez un fichier de configuration OpenSSL.

      Dans l'exemple suivant, le fichier de configuration (example.cnf) contient la section [ca_exts], qui spécifie les extensions X.509 qui marquent le certificat comme adapté à une autorité de certification (CA). L'attribut extendedKeyUsage est défini sur clientAuth. Pour en savoir plus sur les exigences concernant les certificats racine et intermédiaires, consultez la section Exigences concernant les certificats.

        cat > example.cnf << EOF
  [req]
  distinguished_name = empty_distinguished_name

  [empty_distinguished_name]
  # Kept empty to allow setting via -subj command-line argument.

  [ca_exts]
  basicConstraints=critical,CA:TRUE
  keyUsage=keyCertSign
  extendedKeyUsage=clientAuth

  EOF

    2. Créez un certificat d'autorité de certification racine X.509 autosigné (root.cert). Le certificat racine est autosigné avec sa propre clé privée (root.key).

        openssl req -x509 \
      -new -sha256 -newkey rsa:2048 -nodes \
      -days 3650 -subj '/CN=root' \
      -config example.cnf \
      -extensions ca_exts \
      -keyout root.key -out root.cert

    3. Créez un fichier de configuration pour générer la CSR du certificat client.

      Le fichier de configuration suivant (client.config) contient la section [extension_requirements], qui spécifie les extensions X.509 à inclure dans la CSR. Pour en savoir plus sur les exigences concernant les certificats client, consultez la section Exigences concernant les certificats.

        cat > client.config << EOF
  [req]
  default_bits              = 2048
  req_extensions            = extension_requirements
  distinguished_name        = dn_requirements
  prompt                    = no

  [extension_requirements]
  basicConstraints          = critical, CA:FALSE
  keyUsage                  = critical, nonRepudiation, digitalSignature, keyEncipherment
  extendedKeyUsage          = clientAuth

  [dn_requirements]
  countryName               = US
  stateOrProvinceName       = California
  localityName              = San Francisco
  0.organizationName        = example
  organizationalUnitName    = test
  commonName                = test.example.com
  emailAddress              = test@example.com

  EOF

    4. Créez la CSR (client.csr) pour le certificat client.

        openssl req -new \
      -config client.config \
      -keyout client.key -out client.csr

    5. Créez le certificat client (client.cert) à partir de la CSR. La CSR est signée par le certificat de l'autorité de certification racine pour émettre le certificat client X.509.

        openssl x509 -req \
      -CAkey root.key -CA root.cert \
      -days 365 \
      -extfile client.config \
      -extensions extension_requirements \
      -in client.csr -out client.cert

    Importer le certificat client dans le gestionnaire de certificats

    Pour importer le certificat client dans le Gestionnaire de certificats, procédez comme suit:

    Console

    1. Dans la console Google Cloud, accédez à la page Gestionnaire de certificats.

      Accéder au Gestionnaire de certificats

    2. Dans l'onglet Certificats, cliquez sur Ajouter un certificat.

    3. Attribuez un nom au certificat.

      Ce nom doit être unique au projet.

    4. Facultatif: saisissez une description du certificat. La description vous permet d'identifier un certificat spécifique plus tard.

    5. Dans Emplacement, sélectionnez Mondial.

    6. Dans Champ d'application, sélectionnez Authentification client.

    7. Dans Type de certificat, sélectionnez Créer un certificat autogéré.

    8. Pour le champ Certificat, importez un fichier de certificat encodé au format PEM ou copiez et collez le contenu d'un certificat encodé au format PEM.

    9. Pour le champ Certificat de clé privée, importez une clé privée encodée au format PEM qui n'est pas protégée par une phrase secrète, ou copiez et collez le contenu de la clé privée encodée au format PEM.

    10. Spécifiez un libellé à associer au certificat. Si nécessaire, vous pouvez ajouter plusieurs libellés. Pour ajouter un libellé, cliquez sur le bouton Ajouter un libellé, puis spécifiez un key et un value pour votre libellé.

    11. Cliquez sur Créer. Vérifiez que le nouveau certificat apparaît dans la liste des certificats.

    gcloud

    1. Pour importer le certificat client dans le gestionnaire de certificats, utilisez la commande gcloud certificate-manager certificates create. Le champ d'application de ce certificat est client-auth, ce qui indique qu'il est utilisé comme certificat client dans le backend mTLS.

      gcloud certificate-manager certificates create CLIENT_ CERTIFICATE_NAME \
    --certificate-file=client.cert \
    --private-key-file=client.key \
    --scope=client-auth \
    --global

      Remplacez les éléments suivants :

      • CLIENT_CERTIFICATE_NAME: nom de la ressource de certificat client. Ce certificat client avec le champ d'application client-auth est utilisé par la ressource de configuration d'authentification du backend.

    Créer une ressource de configuration d'authentification de backend

    Pour créer une ressource de configuration d'authentification du backend (BackendAuthenticationConfig), procédez comme suit :

    Console

    1. Dans la console Google Cloud, accédez à la page Authentication Configuration (Configuration de l'authentification).

      Accéder à la page "Configuration de l'authentification"

    2. Dans l'onglet Authentification backend, cliquez sur Créer.
    3. Saisissez un nom pour la ressource de configuration d'authentification de backend.
    4. Sélectionnez la ressource de certificat client que vous avez créée précédemment.
    5. Facultatif: sélectionnez les racines publiques de confiance.
    6. Sélectionnez la ressource de configuration de confiance que vous avez créée précédemment.
    7. Cliquez sur Créer.

    Vérifiez que la ressource "Configuration de l'authentification du backend" s'affiche.

    gcloud

    1. Créez un fichier YAML qui spécifie de manière déclarative les différents attributs de la ressource de configuration de l'authentification du backend.

      Associez le certificat client à la ressource de configuration de l'authentification du backend pour activer mTLS du backend.

      cat << EOF > BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml
name: projects/PROJECT_ID/locations/global/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
trustConfig: projects/PROJECT_ID/locations/global/trustConfigs/TRUST_CONFIG_NAME
clientCertificate: projects/PROJECT_ID/locations/global/certificates/CLIENT_ CERTIFICATE_NAME
wellKnownRoots: PUBLIC_ROOTS
EOF

      Remplacez les éléments suivants :

      • BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME : nom du fichier YAML dans lequel la ressource de configuration d'authentification de backend est définie.
      • PROJECT_ID: ID de votre projet Google Cloud
      • BACKEND_AUTH_CONFIG_NAME: nom de la ressource de configuration d'authentification de backend
      • TRUST_CONFIG_NAME: nom de la ressource de configuration de confiance que vous avez créée précédemment.
      • CLIENT_CERTIFICATE_NAME: nom de la ressource de certificat client que vous avez créée précédemment.

    2. Pour importer la ressource de configuration de l'authentification du backend, utilisez la commande gcloud beta network-security backend-authentication-configs import:

      gcloud beta network-security backend-authentication-configs import BACKEND_AUTH_CONFIG_NAME \
   --source=BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml \
   --location=global

      Remplacez les éléments suivants :

      • BACKEND_AUTH_CONFIG_NAME: nom de la ressource de configuration de l'authentification du backend

      • BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME : nom du fichier YAML dans lequel la ressource de configuration de l'authentification du backend est définie.

    Associer la ressource de configuration de l'authentification de backend au service de backend de l'équilibreur de charge

    Pour associer la ressource de configuration d'authentification de backend (BackendAuthenticationConfig) au service de backend de l'équilibreur de charge, procédez comme suit :

    Console

    1. Dans Google Cloud Console, accédez à la page Équilibrage de charge.

      Accéder à la page "Équilibrage de charge"

    2. Dans l'onglet Backends, sélectionnez le service de backend pour lequel vous devez activer le TLS authentifié et le mTLS de backend.

    3. Cliquez sur Modifier ().

    4. Développez la section Configurations avancées.

    5. Dans la section Authentification du backend, cochez la case Activer.

    6. Facultatif: spécifiez le nom d'hôte SNI et les SAN acceptés pour valider le certificat du backend.

    7. Pour associer la ressource de configuration de l'authentification du backend au service de backend, dans la liste Configuration de l'authentification du backend, sélectionnez la ressource de configuration de l'authentification du backend.

    8. Cliquez sur Continuer.

    9. Pour mettre à jour les paramètres du service de backend, cliquez sur Mettre à jour.

    gcloud

    1. Pour répertorier toutes les ressources de service de backend de votre projet, exécutez la commande gcloud compute backend-services list.

      gcloud compute backend-services list

      Notez le nom du service de backend auquel associer la ressource BackendAuthenticationConfig. Ce nom sera appelé BACKEND_SERVICE_NAME dans les étapes suivantes.

    2. Pour exporter la configuration du service de backend vers un fichier, utilisez la commande gcloud beta compute backend-services export.

      gcloud beta compute backend-services export BACKEND_SERVICE_NAME \
    --destination=BACKEND_SERVICE_FILENAME.yaml \
    --global

      Remplacez les éléments suivants :

      • BACKEND_SERVICE_NAME : Nom du service de backend.
      • BACKEND_SERVICE_FILENAME: nom et chemin d'accès à un fichier YAML dans lequel la configuration du service backend est exportée

    3. Mettez à jour l'attribut tlsSettings du service de backend en le pointant vers la ressource de configuration de l'authentification de backend. En outre, vous pouvez configurer le nom d'hôte SNI et les SAN acceptés sur le service de backend pour valider le certificat de backend.

        cat << EOF >> BACKEND_SERVICE_FILENAME.yaml
  tlsSettings:
    authenticationConfig: //networksecurity.googleapis.com/projects/PROJECT_ID/locations/global/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
    sni: examplepetstore.com
    subjectAltNames:
    - dnsName: examplepetstore.com
    - dnsName: api.examplepetstore.com
  EOF

      Les valeurs SNI et SAN de la déclaration YAML précédente ne sont fournies qu'à titre d'exemple. Vous pouvez les remplacer par des valeurs réelles pertinentes pour votre configuration.

      Remplacez les éléments suivants :

      • BACKEND_SERVICE_FILENAME: nom du fichier YAML dans lequel la configuration du service backend est exportée

      • PROJECT_ID : ID de votre projet Google Cloud

      • BACKEND_AUTH_CONFIG_NAME: nom de la ressource de configuration de l'authentification du backend

    4. Pour importer la configuration du service de backend mise à jour à partir d'un fichier, utilisez la commande gcloud beta compute backend-services import.

      gcloud beta compute backend-services import BACKEND_SERVICE_NAME \
    --source=BACKEND_SERVICE_FILENAME.yaml \
    --global

      Remplacez les éléments suivants :

      • BACKEND_SERVICE_NAME : Nom du service de backend.
      • BACKEND_SERVICE_FILENAME: nom du fichier YAML de configuration du service de backend

    Créer un certificat de serveur backend

    Cette section fournit une option de configuration supplémentaire pour créer un certificat de serveur (d'entité finale) signé par le certificat intermédiaire, qui fait partie de la configuration de confiance. Cela garantit qu'une chaîne de confiance peut être établie à partir du certificat du serveur jusqu'à l'ancre de confiance.

    Si vous avez déjà créé une ressource de configuration de confiance contenant un certificat intermédiaire, procédez comme suit:

    1. Créez un fichier de configuration pour générer la CSR du certificat de serveur.

      Le fichier de configuration suivant (server.config) contient la section [extension_requirements], qui spécifie les extensions X.509 à inclure dans la CSR. Pour en savoir plus sur les exigences concernant les certificats de serveur, consultez la section Exigences concernant les certificats.

      cat > server.config << EOF
[req]
default_bits              = 2048
req_extensions            = extension_requirements
distinguished_name        = dn_requirements
prompt                    = no

[extension_requirements]
basicConstraints          = critical, CA:FALSE
keyUsage                  = critical, nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage          = serverAuth
subjectAltName            = @alt_names

[alt_names]
DNS.1 = examplepetstore.com
DNS.2 = api.examplepetstore.com

[dn_requirements]
countryName               = US
stateOrProvinceName       = California
localityName              = San Francisco
0.organizationName        = example
organizationalUnitName    = test
commonName                = examplepetstore.com
emailAddress              = test@examplepetstore.com

EOF

    2. Créez la CSR (server.csr) pour le certificat de serveur.

      openssl req -new \
    -sha256 -newkey rsa:2048 -nodes \
    -config server.config \
    -keyout server.key -out server.csr

    3. Signez la CSR pour émettre le certificat de serveur X.509 (server.cert). La CSR est signée par le certificat intermédiaire.

      openssl x509 -req \
    -CAkey int.key -CA int.cert \
    -days 365 \
    -extfile server.config \
    -extensions extension_requirements \
    -in server.csr -out server.cert

      Lorsque l'équilibreur de charge se connecte au serveur backend, le serveur backend présente son certificat (server.cert) pour s'authentifier auprès de l'équilibreur de charge, ce qui termine le processus d'authentification du backend.

    Options de configuration SSL supplémentaires sur un serveur Web Apache

    Cette section facultative vous explique comment mettre à jour les options de configuration SSL sur un serveur Apache en fonction des certificats client et serveur que vous avez créés précédemment.

    1. Copiez la clé privée (server.key) et le certificat de serveur (server.cert) sur le serveur Web Apache.

          cat > server.key << EOF
    -----BEGIN PRIVATE KEY-----
    [...]
    -----END PRIVATE KEY-----
    EOF

    sudo cp ./server.key /etc/ssl/private/server.key

      Remplacez [...] par la clé privée du serveur encodée au format PEM que vous avez créée précédemment.

          cat > server.cert << EOF
    -----BEGIN CERTIFICATE-----
    [...]
    -----END CERTIFICATE-----
    EOF

    sudo cp ./server.cert /etc/ssl/certs/server.cert

      Remplacez [...] par le certificat de serveur encodé en PEM que vous avez créé précédemment.

    2. Importez le certificat client dans la configuration de confiance du serveur afin de valider le certificat client.

            cat > client.cert << EOF
      -----BEGIN CERTIFICATE-----
      [...]
      -----END CERTIFICATE-----
      EOF

      sudo cp ./client.cert /etc/ssl/certs/client.cert

      Remplacez [...] par le certificat client encodé en PEM que vous avez créé précédemment.

    3. Mettez à jour la configuration SSL du serveur Web Apache.

      Mettez à jour la configuration SSL d'Apache pour activer le trafic HTTPS à l'aide du certificat SSL et de la clé privée spécifiés.

          sudo vi /etc/apache2/sites-available/default-ssl.conf

    ----
    SSLCertificateFile      /etc/ssl/certs/server.cert
    SSLCertificateKeyFile /etc/ssl/private/server.key
    ----

      Mettez à jour la configuration SSL d'Apache pour exiger l'authentification par certificat client et spécifiez le certificat CA pour la validation.

          sudo vi /etc/apache2/sites-available/default-ssl.conf

    ----
    SSLVerifyClient require
    SSLVerifyDepth 5
    SSLCACertificateFile /etc/ssl/certs/client.cert
    ----

    4. Recalculer les hachages des certificats CA.

          sudo c_rehash /etc/ssl/certs/

    5. Redémarrez le serveur Web Apache pour appliquer les modifications.

          sudo systemctl restart apache2.service

    Étape suivante