Journaux d'audit 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.

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

Attribuer le rôle "Utilisateur de compte de service"

Un membre peut obtenir les mêmes autorisations que celles d'un compte de service en empruntant l'identité de celui-ci. Pour autoriser un membre à 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 membre :

{
  "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 membre de créer des identifiants éphémères, Cloud IAM génère une entrée de journal similaire.

Accorder à un compte de service l'accès à 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 membre 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"
  }
}

Configurer une instance Compute Engine pour qu'elle s'exécute sous l'identité d'un 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"
  }
}

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

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

S'authentifier à 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"
    }
  }
}

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.

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 membres 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 membre crée des identifiants éphémères. Cette entrée comprend les champs suivants :

  • protoPayload.authenticationInfo.principalEmail : membre 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"
  }
}

S'authentifier à 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