Cette page a été traduite par l'API Cloud Translation.

Configurer mTLS pour le backend

Cette page explique comment 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 de backend est semblable à celle du TLS authentifié de backend, sauf que vous devez également créer un certificat pour l'équilibreur de charge. Ce certificat, également appelé certificat client, est associé à la ressource Backend Authentication Config. L'équilibreur de charge utilise ce certificat client pour s'authentifier auprès des backends.

Pour configurer le mTLS de backend, suivez les étapes décrites dans les sections suivantes :

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

Avant de commencer

Consultez la présentation de la TLS authentifiée et du mTLS pour le backend.
Consultez Gérer les configurations de confiance.
Si vous souhaitez suivre les instructions de ce guide à l'aide de Google Cloud CLI, vous devez l'installer. Vous trouverez des commandes liées à l'équilibrage de charge dans la documentation de référence de l'API et de gcloud CLI.

Si vous n'avez pas encore utilisé gcloud CLI, exécutez d'abord la commande gcloud init pour vous authentifier.
Activez les API suivantes : API Compute Engine, API Certificate Manager, sécurité réseau et API Network Services. Pour en savoir plus, consultez Activer des API.
Configurez un équilibreur de charge d'application externe global avec l'un des backends compatibles suivants :
- Backends de groupe d'instances de VM
- NEG de connectivité hybride
- NEG zonaux

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 Google Cloud projet cible
Créer un certificat client	`certificatemanager.certs.create` sur le Google Cloud projet 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
Associez la ressource de configuration d'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 protocole mTLS du backend en fonction de l'architecture présentée dans le schéma suivant :

Composants de mTLS backend. — Composants mTLS de backend (cliquez pour agrandir).

Créer les certificats racine et intermédiaire

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

Un certificat racine se trouve en haut 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 entre le certificat de serveur et l'ancre de confiance configurée.

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

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 indiquent que le certificat convient à une autorité de certification. Pour en savoir plus sur les exigences concernant les certificats racine et intermédiaires, consultez 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
```

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

Créez la demande 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

Signez la CSR pour créer le certificat intermédiaire X.509 (int.cert). La CSR 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 du truststore.

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 l'approbation, procédez comme suit :

Console

Dans la console Google Cloud , accédez à la page Certificate Manager.

Accéder au Gestionnaire de certificats
Dans l'onglet Configurations d'approbation, cliquez sur Ajouter une configuration d'approbation.
Attribuez un nom à la configuration.
Dans Emplacement, sélectionnez Mondial. L'emplacement indique 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.
Dans la section Truststore, cliquez sur Ajouter une ancre de confiance et importez le fichier de certificat encodé au format PEM, ou copiez le contenu du certificat.
Cliquez sur Ajouter.
Dans la section Truststore, cliquez sur Ajouter une autorité de certification intermédiaire, puis importez le fichier de certificat encodé au format PEM ou copiez le contenu du certificat. Cette étape vous permet d'ajouter un niveau de confiance entre le certificat racine et le certificat de votre serveur.
Cliquez sur Ajouter pour ajouter l'autorité de certification intermédiaire.
Pour ajouter le certificat que vous avez ajouté à la liste d'autorisation, cliquez sur Ajouter.
Cliquez sur Créer.

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

gcloud

Créez un fichier YAML de configuration de l'approbation (trust_config.yaml) qui spécifie les paramètres de configuration de l'approbation. Cet exemple de ressource de configuration de confiance contient un truststore avec une ancre de confiance et un certificat intermédiaire. Cette 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 intermédiaires, ajoutez des lignes pemCertificate dans la section appropriée.
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 protocole mTLS de backend, l'équilibreur de charge agit en tant que client et le backend en tant que serveur.

Pour activer le protocole mTLS de 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 de backend doit valider le certificat client à l'aide de sa propre chaîne de confiance.

Lors de la connexion à 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) figurant dans le certificat du serveur backend.

Les certificats client peuvent être des certificats gérés provenant d'une autorité de certification privée via Certificate Authority Service ou des certificats PKI privés autogérés. Dans cet exemple, le certificat client est émis à 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 :

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 indiquent que le certificat convient à 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 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
```

Créez un certificat CA 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

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 RDC. Pour en savoir plus sur les exigences concernant les certificats client, consultez 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

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

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

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 Certificate Manager, procédez comme suit :

Console

Dans la console Google Cloud , accédez à la page Certificate Manager.

Accéder au Gestionnaire de certificats
Dans l'onglet Certificats, cliquez sur Ajouter un certificat.
Attribuez un nom au certificat.

Ce nom doit être unique au projet.
Facultatif : saisissez une description du certificat. La description vous aide à identifier un certificat spécifique ultérieurement.
Dans Emplacement, sélectionnez Mondial.
Pour Scope (Portée), sélectionnez Client Authentication (Authentification du client).
Dans Type de certificat, sélectionnez Créer un certificat autogéré.
Dans 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.
Dans 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.
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 une clé (key) et une valeur (value) pour votre libellé.
Cliquez sur Créer. Vérifiez que le nouveau certificat apparaît dans la liste des certificats.

gcloud

Pour importer le certificat client dans le gestionnaire de certificats, utilisez la commande gcloud certificate-manager certificates create. La portée de ce certificat est client-auth, ce qui indique qu'il est utilisé comme certificat client dans le protocole mTLS du backend.
```
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 de backend.

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

Pour créer une ressource Backend Authentication Config (BackendAuthenticationConfig), procédez comme suit.

Console

Dans la console Google Cloud , accédez à la page Configuration de l'authentification.
Accéder à la configuration de l'authentification
Dans l'onglet Authentification du backend, cliquez sur Créer.
Saisissez un nom pour la ressource de configuration d'authentification de backend.
Sélectionnez la ressource de certificat client que vous avez créée précédemment.
Facultatif : Sélectionnez les racines de confiance publiques.
Sélectionnez la ressource de configuration de confiance que vous avez créée précédemment.
Cliquez sur Créer.

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

gcloud

Créez un fichier YAML qui spécifie de manière déclarative les différents attributs de la ressource Backend Authentication Config.

Associez le certificat client à la ressource de configuration d'authentification de backend pour activer le mTLS de 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 de l'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.
Pour importer la ressource de configuration de l'authentification du backend, utilisez la commande gcloud network-security backend-authentication-configs import :
```
gcloud 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 Backend Authentication Config est définie.

Associez la ressource de configuration d'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

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

Accéder à la page "Équilibrage de charge"
Dans l'onglet Backends, sélectionnez le service de backend pour lequel vous devez activer la TLS authentifiée et la mTLS mutuelle pour le backend.
Cliquez sur Modifier ().
Développez la section Configurations avancées.
Dans la section Authentification du backend, cochez la case Activer.
Facultatif : Spécifiez le nom d'hôte SNI et les SAN acceptés pour valider le certificat de backend.
Pour associer la ressource de configuration d'authentification de backend au service de backend, sélectionnez-la dans la liste Configuration d'authentification de backend.
Cliquez sur Continuer.
Pour mettre à jour les paramètres du service de backend, cliquez sur Mettre à jour.

gcloud

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.
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 de backend est exportée
Mettez à jour l'attribut tlsSettings du service de backend en le pointant vers la ressource de configuration d'authentification de backend. De plus, 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 qui correspondent à votre configuration.

Remplacez les éléments suivants :
- BACKEND_SERVICE_FILENAME : nom du fichier YAML dans lequel la configuration du service de 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
Pour importer la configuration mise à jour du service de backend à 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 de 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 permet d'établir une chaîne de confiance du certificat de serveur à l'ancrage de confiance.

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

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 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

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

Signez la RDC pour émettre le certificat de serveur X.509 (server.cert). La RDC 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, celui-ci 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.

Copiez la clé privée du serveur (server.key) et le certificat du 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é au format PEM que vous avez créé précédemment.

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é au format PEM que vous avez créé précédemment.

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écifier 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
    ----

Réindexez les certificats CA.
```
    sudo c_rehash /etc/ssl/certs/
    
```
Redémarrez le serveur Web Apache pour appliquer les modifications.
```
    sudo systemctl restart apache2.service
    
```

Configurer mTLS pour le backend Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Autorisations

Vue d'ensemble de la configuration

Créer les certificats racine et intermédiaire

Mettre en forme les certificats

Créer une ressource de configuration de confiance

Console

gcloud

Créer un certificat client

Importer le certificat client dans le gestionnaire de certificats

Console

gcloud

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

Console

gcloud

Associez la ressource de configuration d'authentification de backend au service de backend de l'équilibreur de charge.

Console

gcloud

Créer un certificat de serveur de backend

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

Étapes suivantes

Configurer mTLS pour le backend