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

Émettre des certificats attestant d'une identité tierce

Ce tutoriel explique comment délivrer des certificats qui attestent à l'aide d'une identité tierce réflexion sur l'identité et des pools d'identités de charge de travail.

Vous pouvez utiliser la réflexion d'identité pour créer des certificats correspondant aux l'identité d'un demandeur de certificat. À l'aide de la réflexion sur l'identité, vous pouvez limiter demandeur de certificat non privilégié à ne demander que des certificats ayant une nom d'objet alternatif (SAN) correspondant à l'identité dans son identifiant.

Objectifs

Ce tutoriel explique comment utiliser le service de certification avec des pools d'identité de charge de travail pour fédérer une identité tierce et obtenir un certificat attestant de cette identité.

Avant de commencer

Avant de commencer, assurez-vous de bien comprendre les concepts suivants :

Pools d'identités de charge de travail : les pools d'identités de charge de travail vous permettent de gérer des fournisseurs d'identité tiers. Pour en savoir plus, consultez la section Gérer les pools d'identités de charge de travail et les fournisseurs.
Fédération d'identité de charge de travail: la fédération d'identité de charge de travail exploite pools d'identités de charge de travail pour autoriser des identités tierces à accéder à Google Cloud services. Pour en savoir plus, consultez la section Fédération d'identité de charge de travail.
Security Token Service (STS) : le service de jetons de sécurité vous permet d'échanger des identifiants tiers contre des jetons propriétaires (Google Cloud). Pour plus plus d'informations, consultez la section Security Token Service.
Réflexion sur l'identité: la fonctionnalité de réflexion d'identité permet l’identité d’un demandeur de certificat accéder au certificat demandé. Pour pour en savoir plus, consultez la section Identité réflexion.

Assurez-vous de disposer des ressources IAM suivantes : rôles:

Pour gérer les autorités de certification et les pools d'autorités de certification, demander vous devez disposer du rôle CA Service Operation Manager, (privateca.caManager). Pour en savoir plus sur IAM pour le service CA, consultez Contrôle des accès avec IAM
Pour gérer les pools d'identités de charge de travail et les fournisseurs, vous devez disposer du Rôle d'administrateur de pools Workload Identity (iam.workloadIdentityPoolAdmin).
Pour créer un compte de service, vous devez disposer du rôle Administrateur de compte de service (iam.serviceAccountAdmin).

Pour en savoir plus sur l'attribution de rôles IAM, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations. Vous pouvez attribuer les rôles IAM requis à un compte Google, un compte de service, un groupe Google, un compte Google Workspace ou un domaine Cloud Identity.

Configurer un pool d'identités de charge de travail et un fournisseur

Ce tutoriel explique comment utiliser Google OpenID Connect (OIDC) associé à un compte de service pour agir en tant qu'identité tierce. La Le fournisseur OIDC de comptes Google agit en tant que fournisseur d'identité (IdP) tiers. le compte de service Google Cloud est un exemple d'identité tierce revendiquée par cet IdP.

Les pools d'identités de charge de travail sont compatibles avec divers fournisseurs d'identité, y compris Microsoft Azure/Active Directory sur site, AWS et les fournisseurs d'identité basés sur SAML.

Pour configurer un pool d'identités de charge de travail et un fournisseur, procédez comme suit: 1. Pour représenter un ensemble d'identités fédérées de confiance, créez une charge de travail d'identités:

```
gcloud iam workload-identity-pools create IDENTITY_POOL_ID --location global --display-name "tutorial-wip"
```

Replace the following:

- <var>IDENTITY_POOL_ID</var>: The unique identifier of the new workload
  identity pool.

Créer un fournisseur de pool d'identités de charge de travail pour votre identité tierce fournisseur:
```
gcloud iam workload-identity-pools providers create-oidc PROVIDER_ID --location global --workload-identity-pool IDENTITY_POOL_ID --display-name "tutorial-oidc" --attribute-mapping "google.subject=assertion.sub" --issuer-uri="https://accounts.google.com"
```
Remplacez les éléments suivants :
- PROVIDER_ID: identifiant unique du fournisseur d'identité à créer dans le pool d'identités de charge de travail.
Vous pouvez personnaliser les options suivantes en fonction de votre cas d'utilisation :
- attribute-mapping: cet indicateur définit le mappage entre les revendique la revendication principale de Google, google.subject. google.subject est un mappage obligatoire que vous pouvez définir sur n'importe quelle revendication ou combinaison de à l'aide d'une requête CEL . Pour en savoir plus, consultez Définir un mappage d'attributs et condition.
- issuer-uri: pour les fournisseurs OIDC, cette option est accessible au public point de terminaison que Google contacte pour valider de jetons. Pour en savoir plus, consultez la page Préparer une identité externe d'un fournisseur de services.
Pour en savoir plus sur la configuration d'une identité de charge de travail consultez la page Configurer Workload Identity fédération.

Créer un pool d'autorités de certification et une autorité d'émission

Cette section explique comment créer un pool d'autorités de certification et ajouter une racine de l'autorité de certification. Vous pouvez utiliser ce pool d'autorités de certification pour émettre des certificats reflétant l'identité. Si vous souhaitez utiliser un pool d'autorités de certification et une autorité de certification existants, vous pouvez ignorer cette section.

Au lieu d'une AC racine, vous pouvez également choisir de créer une AC subordonnée. La création d'une autorité de certification racine permet de raccourcir la procédure.

Créez un pool d'autorités de certification au niveau DevOps :
```
gcloud privateca pools create CA_POOL_ID --location LOCATION --tier devops
```
Remplacez les éléments suivants :
- CA_POOL_ID : ID du pool d'autorités de certification du service CA qui émet des certificats.
- LOCATION : emplacement du pool d'autorités de certification.
Pour en savoir plus sur la création de pools d'autorités de certification, consultez Créez un pool d'autorités de certification.
Créez une autorité de certification racine :
```
gcloud privateca roots create CA_ID --pool CA_POOL_ID  --location LOCATION --subject "CN=test,O=test-org"
```
Remplacez les éléments suivants :
- CA_ID : ID de l'autorité de certification qui émet les certificats.
- CA_POOL_ID : ID du pool d'autorités de certification du service CA qui émet des certificats.
- LOCATION : emplacement du pool d'autorités de certification.
Pour en savoir plus sur la création d'une autorité de certification racine, consultez la section Créer une autorité de certification racine.
Activez les identités fédérées à partir du pool d'identités de charge de travail pour émettre des certificats à partir du pool d'autorités de certification. La réflexion de l'identité nécessite Demandeur de certificat de charge de travail du service CA (roles/privateca.workloadCertificateRequester) Rôle IAM de demandeurs de CreateCertificate.

Vous pouvez représenter les principaux de pool d'identités de charge de travail avec différentes précisions, allant d'un seul sujet à toutes les identités du pool entre les fournisseurs. Pour en savoir plus, consultez la section Comptes principaux ou ensembles de comptes principaux disponibles (utilisez l'onglet Google Cloud CLI) afin de répondre au mieux à votre cas d'utilisation.

Remarque : Vous n'avez pas besoin d'usurper l'identité d'un compte de service pour contacter le service d'autorité de certification.
```
gcloud privateca pools add-iam-policy-binding CA_POOL_ID --location LOCATION --role roles/privateca.workloadCertificateRequester --member "principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/IDENTITY_POOL_ID/*"
```
Remplacez les éléments suivants :
- PROJECT_NUMBER : numéro du projet dans lequel vous avez créé le pool d'identités de charge de travail.

Créer un compte de service représentant une identité tierce

La procédure suivante suppose qu'un compte de service représente un tiers. Cette section explique comment utiliser le point de terminaison IAM GenerateIdToken pour récupérer une identité tierce sous la forme d'un jeton OIDC. Selon votre cas d'utilisation, vous devrez peut-être suivre différentes étapes pour obtenir le jeton d'identité tiers de votre choix.

gcloud iam service-accounts create SERVICE_ACCOUNT

Remplacez les éléments suivants :

SERVICE_ACCOUNT : ID du compte de service représentant l'identité tierce.

Émettre un certificat attestant d'une identité tierce

Avant de commencer, assurez-vous que vous disposez du créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator) rôle IAM. Vous avez besoin de ce rôle IAM pour appeler l'API GenerateIdToken.

Pour obtenir un certificat attestant d'une identité tierce, exécutez la suivantes:

Obtenez un jeton d'identité tiers auprès de votre fournisseur d'identité tiers.
curl
Remarque :Pour exécuter cette commande, vous avez besoin de la propriété python3 CLI.
```
export ID_TOKEN=`curl -d '{"audience":"//iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/IDENTITY_POOL_ID/providers/PROVIDER_ID"}' -H 'Content-Type: application/json' -H "Authorization: Bearer $(gcloud auth print-access-token)" https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com:generateIdToken | python3 -c "import sys;import json;print(json.load(sys.stdin)['token'])"`
```
Remplacez les éléments suivants :
- PROJECT_ID : ID du projet Google Cloud associé au projet souhaitez créer des ressources.
Bibliothèques clientes
Remarque :Ce flux nécessite les bibliothèques clientes Python pour d'autorité de certification. Pour plus d'informations sur l'installation de la bibliothèque cliente Python bibliothèques clientes, consultez la section Client Python CA Service

Pour accéder au jeton tiers de manière programmatique, vous pouvez obtenir un jeton à partir d'identifiants issus d'un fichier ou d'une URL. Pour plus d'informations, consultez la section S'authentifier à l'aide de bibliothèques clientes, de la gcloud CLI, ou Terraform. Dans ce tutoriel, nous allons suivre un workflow d'identifiants de source de fichier.

Chargez vos identifiants dans un chemin d'accès lisible par votre certificat. demandeur:
```
curl -d '{"audience":"//iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/IDENTITY_POOL_ID/providers/PROVIDER_ID"}' -H 'Content-Type: application/json' -H "Authorization: Bearer $(gcloud auth print-access-token)" https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com:generateIdToken | python3 -c "import sys;import json;       print(json.load(sys.stdin)['token']) > /tmp/oidc_token.txt
```
Remplacez les éléments suivants :
- PROJECT_ID : ID du projet dans lequel vous souhaitez créer des ressources.

Échangez votre jeton tiers contre un jeton OAuth fédéré à l'aide du point de terminaison token du STS :

curl

export STS_TOKEN=`curl -L -X POST 'https://sts.googleapis.com/v1/token' -H 'Content-Type: application/json' \
-d '{
    "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
    "audience": "//iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/IDENTITY_POOL_ID/providers/PROVIDER_ID",
    "requested_token_type": "urn:ietf:params:oauth:token-type:access_token",
    "scope": "https://www.googleapis.com/auth/cloud-platform",
    "subject_token": "'$ID_TOKEN'",
    "subject_token_type": "urn:ietf:params:oauth:token-type:jwt"
}' | python3 -c "import sys;import json; print(json.load(sys.stdin)['access_token'])"`

Bibliothèques clientes

Créer un identifiant de configuration nommé oidc_token.txt que le certificat qui demande le code peut lire pour effectuer un échange de jetons.

gcloud iam workload-identity-pools create-cred-config projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/IDENTITY_POOL_ID --output-file=/tmp/cred_config.json --credential-source-file=/tmp/oidc_token.txt

Lisez le fichier oidc_token.txt pour définir le mécanisme d'autorisation dans la bibliothèque cliente :

python

import json

from google.auth import identity_pool

with open('/tmp/cred_config.json', 'r') as f:
  json_config_info = json.loads(f.read())
credentials = identity_pool.Credentials.from_info(json_config_info)
scoped_credentials = credentials.with_scopes(
    ['https://www.googleapis.com/auth/cloud-platform'])

Envoyez une requête au service CA à l'aide du Mode de requête de l'objet de REFLECTED_SPIFFE:

curl

Facultatif: Si vous n'avez pas de requête de signature de certificat, créez-en une en exécutant la commande la commande suivante.

Remarque :La commande suivante crée une requête de signature de certificat sans objet. CA Service ajoutera un objet reflétant les l'identité de l'utilisateur.
```
export TUTORIAL_CSR=$(openssl req -newkey rsa:2048 -nodes -subj / -keyout tutorial_do_not_use.key)
```

Demandez un certificat avec le CSR, une durée de vie et un Mode de requête de l'objet:

curl -H "Authorization: Bearer $(echo $STS_TOKEN)" https://privateca.googleapis.com/v1/projects/PROJECT_NUMBER/locations/LOCATION/caPools/CA_POOL_ID/certificates\?alt\=json  -X POST -H "Content-Type: application/json" -H 'Accept: application/json' --data '{"lifetime": "100s", "pemCsr": "'$TUTORIAL_CSR'", "subjectMode": "REFLECTED_SPIFFE"}'

Bibliothèques clientes

Pour transférer le jeton propriétaire à CA Service, vous devez créer un client avec identifiants. Vous pouvez ensuite utiliser ce client pour demander des certificats:

Lancez un client de service d'autorité de certification authentifié :

python

caServiceClient = privateca_v1.CertificateAuthorityServiceClient(credentials=scoped_credentials)

Demandez un certificat.

Python

Pour vous authentifier auprès du service CA, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2


def create_certificate(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    certificate_name: str,
    common_name: str,
    domain_name: str,
    certificate_lifetime: int,
    public_key_bytes: bytes,
) -> None:
    """
    Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
    The key used to sign the certificate is created by the Cloud KMS.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set a unique name for the CA pool.
        ca_name: the name of the certificate authority which issues the certificate.
        certificate_name: set a unique name for the certificate.
        common_name: a title for your certificate.
        domain_name: fully qualified domain name for your certificate.
        certificate_lifetime: the validity of the certificate in seconds.
        public_key_bytes: public key used in signing the certificates.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # The public key used to sign the certificate can be generated using any crypto library/framework.
    # Also you can use Cloud KMS to retrieve an already created public key.
    # For more info, see: https://cloud.google.com/kms/docs/retrieve-public-key.

    # Set the Public Key and its format.
    public_key = privateca_v1.PublicKey(
        key=public_key_bytes,
        format_=privateca_v1.PublicKey.KeyFormat.PEM,
    )

    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name),
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain_name]),
    )

    # Set the X.509 fields required for the certificate.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                digital_signature=True,
                key_encipherment=True,
            ),
            extended_key_usage=privateca_v1.KeyUsage.ExtendedKeyUsageOptions(
                server_auth=True,
                client_auth=True,
            ),
        ),
    )

    # Create certificate.
    certificate = privateca_v1.Certificate(
        config=privateca_v1.CertificateConfig(
            public_key=public_key,
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=certificate_lifetime),
    )

    # Create the Certificate Request.
    request = privateca_v1.CreateCertificateRequest(
        parent=caServiceClient.ca_pool_path(project_id, location, ca_pool_name),
        certificate_id=certificate_name,
        certificate=certificate,
        issuing_certificate_authority_id=ca_name,
    )
    result = caServiceClient.create_certificate(request=request)

    print("Certificate creation result:", result)

Vérifiez le certificat. L'objet de votre certificat doit contenir un seul SAN URI. Le SAN qui atteste d'une identité est au format suivant :
```
spiffe://IDENTITY_POOL_ID.PROJECT_NUMBER.global.workload.id.goog/subject/<oidc_subject_number>
```
Remplacez :
- IDENTITY_POOL_ID : identifiant unique du pool d'identités de charge de travail.
- PROJECT_NUMBER : numéro du projet dans vous avez créé le pool d'identités de charge de travail.

Effectuer un nettoyage

Afin d'éviter que des frais ne soient facturés sur votre compte Google Cloud pour les ressources CA Service que vous avez créées à la suite de ce document, les opérations suivantes à l'aide de la Google Cloud CLI:

Supprimez l'autorité de certification que vous avez créée.
1. Désactivez l'autorité de certification :
```
gcloud privateca roots disable CA_ID --pool CA_POOL_ID  --location LOCATION
```
  Remplacez :
  - CA_ID : identifiant unique de l'autorité de certification.
  - CA_POOL_ID: identifiant unique du pool d'autorités de certification.
  - LOCATION: emplacement du pool d'autorités de certification.
2. Supprimez l'autorité de certification:
```
gcloud privateca roots delete CA_ID --pool CA_POOL_ID  --location LOCATION --ignore-active-certificates
```
  Remplacez :
  - CA_ID : identifiant unique de l'autorité de certification.
  - CA_POOL_ID: identifiant unique du pool d'autorités de certification.
  - LOCATION: emplacement du pool d'autorités de certification.
Supprimez le pool d'autorités de certification que vous avez créé.

Remarque :Vous ne pouvez pas supprimer un pool d'autorités de certification tant que vous n'avez pas supprimé définitivement tous les CA qu'il contient. Le délai d'expiration par défaut d'une autorité de certification est de 30 jours.
```
gcloud privateca pools delete CA_POOL_ID --location LOCATION
```
Remplacez :
- CA_POOL_ID: identifiant unique du pool d'autorités de certification.
- LOCATION : emplacement du pool d'autorités de certification.
Pour en savoir plus sur la commande gcloud privateca pools delete, consultez la page gcloud privateca pools delete.
Supprimez le pool d'identités de charge de travail que vous avez créé :
```
gcloud iam workload-identity-pools delete IDENTITY_POOL_ID --location global
```
Remplacez :
- IDENTITY_POOL_ID: identifiant unique de la charge de travail un pool d'identités.
Supprimez le compte de service que vous avez créé :
```
gcloud iam service-accounts delete SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com
```
Remplacez :
- SERVICE_ACCOUNT : identifiant unique du pool d'identités de charge de travail.
- PROJECT_ID: projet auquel appartient le compte de service.

Le rôle IAM Demandeur de certificat de charge de travail du service CA (privateca.workloadCertificateRequester) limite le sujet du certificat émis à l'identité du demandeur uniquement. Assurez-vous que les utilisateurs ou les charges de travail utilisant l'identité de réflexion se voient accorder uniquement Demandeur de certificat de charge de travail (privateca.workloadCertificateRequester) rôle IAM. Pour respecter le principe du moindre privilège, vous pouvez éviter d'attribuer le rôle IAM Demandeur de certificat de service d'autorité de certification (privateca.certificateRequester).

Étape suivante

Découvrez les différents paramètres de stratégie qui vous permettent de contrôler les propriétés du certificat demandé au-delà d'une identité reflétée.
Découvrez comment configurer et gérer diverses stratégies de commande.