Exemples de journaux pour les comptes de service

Cette page présente des exemples de journaux d'audit générés lors de la gestion ou de l'utilisation d'un compte de service.

Pour en savoir plus sur l'activation et l'affichage des journaux d'audit, consultez la page Journaux d'audit Cloud IAM.

Journaux pour la création de comptes de service

Lorsque vous créez ou modifiez un compte de service, Identity and Access Management (IAM) génère des entrées de journal. L'exemple suivant montre une entrée de journal générée par la création d'un compte de service :

{
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "example-user@example.com"
    },
    "methodName": "google.iam.admin.v1.CreateServiceAccount",
    "response": {
      "email": "my-service-account@my-project.iam.gserviceaccount.com",
      "@type": "type.googleapis.com/google.iam.admin.v1.ServiceAccount",
      "display_name": "My service account."
    }
  },
  "resource": {
    "type": "service_account"
  }
}

Journaux d'attribution des rôles

Cette section présente les entrées de journal générées lors de l'attribution de rôles liés aux comptes de service.

Journaux pour l'attribution du rôle Utilisateur du compte de service

Un compte principal peut obtenir les mêmes autorisations que celles d'un compte de service en empruntant l'identité de celui-ci. Pour autoriser un compte principal à emprunter l'identité d'un compte de service, vous pouvez lui attribuer le rôle "Utilisateur de compte de service" (roles/iam.serviceAccountUser).

L'exemple suivant illustre une entrée de journal générée par l'attribution du rôle "Utilisateur de compte de service" à un compte principal :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Factivity",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "methodName": "google.iam.admin.v1.SetIAMPolicy",
    "request": {
      "@type": "type.googleapis.com/google.iam.v1.SetIamPolicyRequest",
      "resource": "projects/-/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com"
    },
    "resourceName": "projects/-/serviceAccounts/123456789012345678901",
    "response": {
      "@type": "type.googleapis.com/google.iam.v1.Policy",
      "bindings": [
        {
          "members": [
            "user:my-user@example.com"
          ],
          "role": "roles/iam.serviceAccountUser"
        }
      ]
    }
  },
  "resource": {
    "type": "service_account"
  }
}

Lorsque vous accordez le rôle "Créateur de jetons de compte de service" (roles/iam.serviceAccountTokenCreator), qui permet à un compte principal de créer des identifiants éphémères, Cloud IAM génère une entrée de journal similaire.

Journaux permettant d'accorder l'accès à un compte de service sur une ressource

Vous pouvez attribuer à un compte de service un rôle lui permettant d'accéder à une ressource spécifique. Si le service propriétaire de la ressource est également compatible avec la journalisation d'audit, l'attribution d'un rôle au compte de service génère une entrée de journal d'audit. L'entrée de journal inclut le champ protoPayload.authenticationInfo.principalEmail, qui identifie le compte principal ayant attribué le rôle au compte de service.

L'exemple suivant montre une entrée de journal d'audit générée par l'attribution d'un rôle à un compte de service pour accéder à un projet. Dans cet exemple, example-user@example.com a attribué le rôle Lecteur d'organisation (roles/resourcemanager.organizationViewer) au compte de service. Le champ protoPayload.serviceName est défini sur cloudresourcemanager.googleapis.com, car Resource Manager est le service Google Cloud qui gère les projets. En outre, le champ resource.type est défini sur project :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Factivity",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "example-user@example.com"
    },
    "methodName": "SetIamPolicy",
    "request": {
      "@type": "type.googleapis.com/google.iam.v1.SetIamPolicyRequest",
      "resource": "my-project"
    },
    "resourceName": "projects/my-project",
    "response": {
      "@type": "type.googleapis.com/google.iam.v1.Policy",
      "bindings": [
        {
          "members": [
            "serviceAccount:my-service-account@my-project.iam.gserviceaccount.com"
          ],
          "role": "roles/resourcemanager.organizationViewer"
        }
      ]
    },
    "serviceName": "cloudresourcemanager.googleapis.com"
  },
  "resource": {
    "type": "project"
  }
}

Journaux sur les associations des comptes de service à des ressources

Si un utilisateur dispose du rôle Utilisateur de compte de service (roles/iam.serviceAccountUser) pour un compte de service, il peut associer le compte de service à des ressources. Lorsque du code exécuté sur la ressource accède aux services et aux ressources Google Cloud, il utilise le compte de service associé à la ressource comme identité. Par exemple, si vous associez un compte de service à une instance Compute Engine et que les applications de l'instance utilisent une bibliothèque cliente pour appeler les API Google Cloud, ces applications utilisent automatiquement le compte de service associé pour l'authentification et l'autorisation.

Cette section présente certains des journaux générés lorsque vous associez un compte de service à une ressource.

Journaux d'utilisation de l'autorisation iam.serviceAccounts.actAs

L'association d'un compte de service à une ressource nécessite l'autorisation iam.serviceAccounts.actAs. Lorsqu'une entité principale utilise cette autorisation pour associer un compte de service à une ressource, elle génère un journal d'audit.

L'exemple suivant montre une entrée de journal pour un compte principal utilisant l'autorisation iam.serviceAccounts.actAs pour associer un compte de service à une instance Compute Engine.

{
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "example-user@example.com"
    },
    "serviceName": "iam.googleapis.com",
    "methodName": "iam.serviceAccounts.actAs",
    "authorizationInfo": [
      {
        "resource": "projects/-/serviceAccounts/sample-service-account@sample-project.iam.gserviceaccount.com",
        "permission": "iam.serviceAccounts.actAs",
        "granted": true,
        "permissionType": "ADMIN_WRITE"
      }
    ],
    "resourceName": "projects/-/serviceAccounts/sample-service-account@sample-project.iam.gserviceaccount.com",
    "request": {
      "name": "sample-service-account@sample-project.iam.gserviceaccount.com",
      "project_number": "787155667719",
      "@type": "type.googleapis.com/CanActAsServiceAccountRequest"
    },
    "response": {
      "success": true,
      "@type": "type.googleapis.com/CanActAsServiceAccountResponse"
    }
  },
  "insertId": "vojt0vd4fdy",
  "resource": {
    "type": "audited_resource",
    "labels": {
      "project_id": "sample-project",
      "method": "iam.serviceAccounts.actAs",
      "service": "iam.googleapis.com"
    }
  },
  "timestamp": "2024-08-05T21:56:56.097601933Z",
  "severity": "NOTICE",
  "logName": "projects/sample-project/logs/cloudaudit.googleapis.com%2Factivity",
  "receiveTimestamp": "2024-08-05T21:56:56.097601933Z"
}

Journaux permettant de configurer une instance Compute Engine à exécuter en tant que compte de service

Si un utilisateur dispose du rôle Utilisateur de compte de service (roles/iam.serviceAccountUser) pour un compte de service, il peut créer une instance de machine virtuelle (VM) Compute Engine qui s'exécute sous l'identité du compte de service. Dans ce scénario, l'utilisateur crée l'instance de VM en utilisant ses propres identifiants, et la requête spécifie le compte de service que l'instance de VM doit utiliser.

Lorsqu'un utilisateur crée une instance de VM, Compute Engine génère plusieurs entrées de journal. L'exemple suivant montre la première entrée de journal, qui identifie le créateur de l'instance de VM et le compte de service qu'elle utilise. Dans cet exemple, l'utilisateur example-user@example.com a créé une instance qui utilise le compte de service my-service-account@my-project.iam.gserviceaccount.com. Par conséquent, le champ protoPayload.authenticationInfo.principalEmail est défini sur example-user@example.com et le champ protoPayload.request.serviceAccounts[0].email sur my-service-account@my-project.iam.gserviceaccount.com :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Factivity",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "example-user@example.com"
    },
    "methodName": "v1.compute.instances.insert",
    "request": {
      "@type": "type.googleapis.com/compute.instances.insert",
      "serviceAccounts": [
        {
          "email": "my-service-account@my-project.iam.gserviceaccount.com"
        }
      ]
    },
    "resourceName": "projects/my-project/zones/us-central1-a/instances/my-instance"
  },
  "resource": {
    "type": "gce_instance"
  }
}

Journaux permettant d'accéder à Google Cloud à l'aide d'une clé de compte de service

Cette section présente les entrées de journal générées lorsque vous créez une clé de compte de service et que vous accédez à Google Cloud à l'aide de cette clé.

Journaux permettant de créer une clé de compte de service

Si vous disposez du rôle Administrateur de clé de compte de service (roles/iam.serviceAccountKeyAdmin) pour un compte de service, vous pouvez créer une clé de compte de service, puis l'utiliser pour authentifier les requêtes auprès des services Google Cloud.

L'exemple suivant montre une entrée de journal générée par la création d'une clé de compte de service. Dans cet exemple, l'utilisateur example-user@example.com a créé une clé pour le compte de service my-service-account@my-project.iam.gserviceaccount.com :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Factivity",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "example-user@example.com",
    },
    "methodName": "google.iam.admin.v1.CreateServiceAccountKey",
    "request": {
      "@type": "type.googleapis.com/google.iam.admin.v1.CreateServiceAccountKeyRequest",
      "name": "projects/-/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com"
    },
    "resourceName": "projects/-/serviceAccounts/123456789012345678901"
  },
  "resource": {
    "type": "service_account"
  }
}

Journaux permettant l'authentification à l'aide d'une clé de compte de service

Une fois la clé de compte de service créée, vous pouvez l'utiliser pour demander un jeton d'accès OAuth 2.0 pour un compte de service, puis authentifier les requêtes auprès des services Google Cloud à l'aide de ce jeton. En général, les journaux d'audit associés à ces services incluent les informations suivantes :

  • protoPayload.authenticationInfo.principalEmail : adresse e-mail du compte de service représenté par le jeton d'accès.
  • protoPayload.authenticationInfo.serviceAccountKeyName : clé de compte de service utilisée pour demander le jeton d'accès OAuth 2.0. Ce champ identifie la clé du compte de service en spécifiant son nom de ressource complet selon le format //iam.googleapis.com/projects/project-id/serviceAccounts/service-account-email/keys/key-id.

L'exemple suivant montre une entrée de journal d'audit générée par une requête de création d'instance Memorystore pour Redis. La requête a été authentifiée à l'aide d'un jeton d'accès OAuth 2.0 pour un compte de service. Dans cet exemple, le compte de service est nommé my-service-account@my-project.iam.gserviceaccount.com et l'ID de clé correspondant est c71e040fb4b71d798ce4baca14e15ab62115aaef :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Factivity",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "my-service-account@my-project.iam.gserviceaccount.com",
      "serviceAccountKeyName": "//iam.googleapis.com/projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com/keys/c71e040fb4b71d798ce4baca14e15ab62115aaef"
    },
    "methodName": "google.cloud.redis.v1.CloudRedis.CreateInstance",
    "request": {
      "@type": "type.googleapis.com/google.cloud.redis.v1.CreateInstanceRequest"
    }
  }
}

Journaux permettant d'emprunter l'identité d'un compte de service pour accéder à Google Cloud

Cette section présente les entrées de journal générées lorsque vous créez des identifiants éphémères pour un compte de service et que vous les utilisez ensuite pour emprunter l'identité du compte de service et accéder à Google Cloud.

Journaux de création des identifiants éphémères

Si vous disposez du rôle Créateur de jetons de compte de service (roles/iam.serviceAccountTokenCreator) pour un compte de service, vous pouvez créer des identifiants éphémères et les utiliser pour emprunter l'identité du compte de service. Par exemple, vous pouvez créer des identifiants éphémères pour appeler une API Google Cloud à partir d'une application qui ne s'exécute pas sur Google Cloud.

Cloud IAM peut générer des journaux d'audit lorsque les comptes principaux créent des identifiants éphémères. Pour recevoir ces journaux d'audit, vous devez activer les journaux d'audit Cloud IAM pour l'accès aux données.

Une fois que vous avez activé les journaux d'audit Cloud IAM pour l'accès aux données, IAM génère une entrée de journal d'audit chaque fois qu'un compte principal crée des identifiants éphémères. Cette entrée comprend les champs suivants :

  • protoPayload.authenticationInfo.principalEmail : compte principal qui a créé les identifiants éphémères
  • resource.labels.email_id : compte de service pour lequel des identifiants éphémères ont été générés

L'exemple suivant montre une entrée de journal d'audit générée pour une requête de création de jeton d'accès OAuth 2.0 éphémère. Dans cet exemple, l'utilisateur example-user@example.com a créé un jeton d'accès pour le compte de service my-service-account@my-project.iam.gserviceaccount.com :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Fdata_access",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "example-user@example.com"
    },
    "methodName": "GenerateAccessToken",
    "request": {
      "@type": "type.googleapis.com/google.iam.credentials.v1.GenerateAccessTokenRequest",
      "name": "projects/-/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com"
    },
    "serviceName": "iamcredentials.googleapis.com"
  },
  "resource": {
    "labels": {
      "email_id": "my-service-account@my-project.iam.gserviceaccount.com",
      "project_id": "my-project",
      "unique_id": "123456789012345678901"
    },
    "type": "service_account"
  }
}

Journaux permettant l'authentification à l'aide d'identifiants éphémères

Une fois les identifiants éphémères créés pour un compte de service, vous pouvez les utiliser pour emprunter l'identité du compte de service lorsque vous appelez les API Google Cloud.

Certaines des méthodes appelées peuvent générer des journaux d'audit. En général, ces entrées de journal indiquent les identités suivantes :

  • Compte de service dont l'identité est empruntée par les identifiants éphémères
  • Identité ayant créé les identifiants éphémères

Par exemple, supposons que l'utilisateur example-user@example.com crée des identifiants éphémères pour le compte de service my-service-account@my-project.iam.gserviceaccount.com. Il crée ensuite un sujet Pub/Sub, puis utilise les identifiants éphémères pour emprunter l'identité du compte de service. Pub/Sub génère alors une entrée de journal identifiant le compte de service, ainsi que l'utilisateur qui en a emprunté l'identité :

{
  "logName": "projects/my-project/logs/cloudaudit.googleapis.com%2Factivity",
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "my-service-account@my-project.iam.gserviceaccount.com",
      "serviceAccountDelegationInfo": [
        {
          "firstPartyPrincipal": {
            "principalEmail": "example-user@example.com"
          }
        }
      ]
    },
    "methodName": "google.pubsub.v1.Publisher.CreateTopic",
    "request": {
      "@type": "type.googleapis.com/google.pubsub.v1.Topic",
      "name": "projects/my-project/topics/my-topic"
    },
    "resourceName": "projects/my-project/topics/my-topic"
  },
  "resource": {
    "type": "pubsub_topic"
  }
}

Journaux des actions effectuées par les agents de service

Parfois, lorsqu'un utilisateur principal lance une opération, un agent de service exécute une action en son nom. Toutefois, lorsque vous examinez les journaux d'audit d'un agent de service, il peut être difficile de déterminer pour qui l'agent de service agissait et pourquoi.

Pour vous aider à comprendre le contexte des actions d'un agent de service, certains agents de service incluent des informations supplémentaires dans leurs journaux d'audit, comme la tâche à laquelle l'action est associée et le compte principal qui a créé la tâche.

Les agents de service suivants incluent ces informations supplémentaires dans leurs journaux d'audit:

Ces informations supplémentaires se trouvent dans le champ serviceDelegationHistory du journal d'audit, qui est imbriqué dans le champ authenticationInfo. Ce champ contient les informations suivantes:

  • Le compte d'utilisateur principal d'origine qui a créé la tâche
  • Agent de service qui a exécuté l'action
  • Service auquel appartient l'agent de service
  • ID du job.

Par exemple, supposons que example-user@example.com crée une tâche à l'aide de l'API BigQuery Connection. Cette tâche nécessite qu'un des agents de service de l'API BigQuery Connection exécute une action. Dans ce cas, le journal d'audit de l'action de l'agent de service contient un champ serviceDelegationHistory semblable à celui-ci: 

{
  "protoPayload": {
    "@type": "type.googleapis.com/google.cloud.audit.AuditLog",
    "authenticationInfo": {
      "principalEmail": "bqcx-442188550395-jujw@gcp-sa-bigquery-condel.iam.gserviceaccount.com",
      "serviceDelegationHistory": {
        "originalPrincipal": "user:my-user@example.com",
        "serviceMetadata": [
          {
            "principalSubject": "serviceAccount:bqcx-442188550395-jujw@gcp-sa-bigquery-condel.iam.gserviceaccount.com",
            "serviceDomain": "bigquery.googleapis.com",
          }
        ]
      }
    }
  }
}

Étape suivante