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": "hao@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 pour l'attribution de 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:srini@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, julia@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": "julia@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 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 jackie@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 jackie@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": "jackie@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 sam@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": "sam@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 permettant de créer 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 amara@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": "amara@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 yoon@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": "yoon@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"
  }
}

Étapes suivantes