Optimierte Zugangsverwaltung mit Zugangsgruppen

Organisieren Sie Benutzer, Service-IDs und vertrauenswürdige Profile in Zugriffsgruppen für eine effiziente Rechteverwaltung. Weisen Sie der gesamten Gruppe einmalig fein abgestufte Richtlinien zu, um das Least Privilege in großem Umfang zu implementieren.

Eine Zugriffsgruppe kann erstellt werden, um eine Gruppe von Benutzern, Service-IDs und vertrauenswürdigen Profilen in einer einzelnen Entität zu organisieren, die Ihnen das Zuweisen von Zugriffsberechtigungen erleichtert. Sie können der Gruppe eine einzelne Richtlinie zuordnen, anstatt denselben Zugriff mehrmals für einen einzelnen Benutzer oder eine einzelne Service-ID zuzuweisen.

Zugriffsgruppen werden Richtlinien zugeordnet, die den Mitgliedern dieser Gruppe Rollen und Berechtigungen erteilen. Eine Zugriffsgruppe kann Mitglieder mit verschiedenen Identitätstypen, wie beispielsweise Benutzer, Service-IDs und vertrauenswürdige Profile, enthalten. Die Mitglieder erben die Richtlinien, Rollen und Berechtigungen, die der Zugriffsgruppe zugewiesen sind, und behalten auch die Rollen, die ihnen individuell zugewiesen wurden.

Wenn einem Benutzer beispielsweise die Rolle viewer für den Abrechnungsservice zugeordnet ist und er zu einer Zugriffsgruppe hinzugefügt wird, die über die Rolle publisher für den Katalogverwaltungsservice verfügt, behält er die Rolle viewer bei, obwohl dies nicht Teil der Berechtigungen für die Zugriffsgruppe ist.

Um die Zuweisung und Verwaltung des Zugriffs noch einfacher zu gestalten, können Sie Ressourcengruppen einrichten, um eine Gruppe von Ressourcen zu organisieren, auf die eine Gruppe von Benutzern Zugriff haben soll. Wenn Ihre Ressourcengruppe eingerichtet ist, können Sie eine Richtlinie zuordnen, die den Zugriff auf alle Ressourcen in dieser Gruppe ermöglicht, anstatt Zugriffsrichtlinien für einzelne Serviceinstanzen innerhalb Ihres Kontos zu erstellen.

Vorbereitende Schritte

Zum Verwalten von Zugriffsgruppen oder zum Erstellen neuer Zugriffsgruppen benötigen Sie die folgenden Zugriffsberechtigungstypen:

  • Administrator oder Bearbeiter für den Kontenverwaltungsservice für IAM-Zugriffsgruppen im Konto
  • Administrator oder Bearbeiter für alle Kontenverwaltungsservices
  • Sie müssen der Kontoinhaber sein

Darüber hinaus kann ein Administrator oder Bearbeiter für die Verwaltung einer einzelnen Gruppe zugewiesen werden, indem eine Zugriffsrichtlinie erstellt wird, deren Ressource die Zugriffsgruppen-ID ist. Weitere Informationen über Zugriffsrichtlinien und Rollen für den IAM-Zugriffsgruppenservice finden Sie im Abschnitt zum IAM-Zugriff.

Vorbereitende Schritte

Bevor Sie mit Terraform Zugriffsgruppen einrichten können, müssen Sie die folgenden Schritte durchführen:

  • Installieren Sie die Terraform CLI und konfigurieren Sie das IBM Cloud Provider Plug-in für Terraform. Weitere Informationen finden Sie in der Anleitung zu den ersten Schritten mit Terraform auf IBM Cloud®. Das Plug-in abstrahiert die IBM Cloud APIs, die zur Erfüllung dieses Tasks verwendet werden.
  • Erstellen Sie eine Terraform-Konfigurationsdatei mit dem Namen main.tf. In dieser Datei definieren Sie die Ressourcen mit Hilfe der HashiCorp Configuration Language. Weitere Informationen finden Sie in der Terraform-Dokumentation.

Zugriffsgruppe in der Konsole erstellen

Zur Unterscheidung von Zugriffsgruppen im Konto ist ein eindeutiger Name erforderlich. Führen Sie die folgenden Schritte aus, um eine Zugriffsgruppe zu erstellen:

  1. Klicken Sie in der IBM Cloud®-Konsole auf Verwalten > Zugriff (IAM) und wählen Sie Zugriffsgruppen aus.
  2. Klicken Sie auf Erstellen.
  3. Geben Sie einen eindeutigen Namen zur Identifizierung der Zugriffsgruppe und optional eine Beschreibung ein und klicken Sie auf Erstellen.

Richten Sie als Nächstes die Gruppen ein, indem Sie Benutzer, Service-IDs oder vertrauenswürdige Profile hinzufügen. Sie können Benutzer manuell oder durch das Erstellen dynamischer Regeln hinzufügen. Sie können auch mit dem Zuweisen des Gruppenzugriffs beginnen und entscheiden, wen Sie der Zugriffsgruppe später hinzufügen möchten.

Sie können eine Gruppe löschen, indem Sie die Option Gruppe entfernen auswählen. Wenn Sie eine Gruppe aus dem Konto entfernen, entfernen Sie alle Benutzer und Service-IDs aus der Gruppe und alle Zugriffsrechte, die der Gruppe zugeordnet sind.

Zugriffsgruppe über die Befehlszeilenschnittstelle (CLI) erstellen

Wenn Sie eine Zugriffsgruppe mithilfe der Befehlszeilenschnittstelle erstellen möchten, können Sie den Befehl ibmcloud iam access-group-create verwenden.

ibmcloud iam access-group-create GROUP_NAME [-d, --description DESCRIPTION]

Zur Unterscheidung von Zugriffsgruppen im Konto ist ein eindeutiger Name erforderlich.

Zugriffsgruppe über die Anwendungsprogrammierschnittstelle (API) erstellen

Sie können Zugriffsgruppen programmatisch erstellen, indem Sie die IBM Cloud® Identity and Access Management(IAM)Access Groups API aufrufen, wie in der folgenden Beispielanforderung gezeigt. In diesem Beispiel wird eine Zugriffsgruppe für die Manager im Konto erstellt:

curl -X POST -H "Authorization: Bearer {iam_token}" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d '{ "name": "Managers", "description": "Group for managers" }' \
"{base_url}/groups?account_id={account_id}"

CreateAccessGroupOptions createAccessGroupOptions = new CreateAccessGroupOptions.Builder()
  .accountId(testAccountId)
  .name("Managers")
  .description("Group for managers")
  .build();

Response<Group> response = service.createAccessGroup(createAccessGroupOptions).execute();
Group group = response.getResult();

System.out.println(group);

const params = {
  accountId: testAccountId,
  name: 'Managers',
  description: 'Group for managers'
};

iamAccessGroupsService.createAccessGroup(params)
  .then(res => {
    testGroupId = res.result.id;
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

group = iam_access_groups_service.create_access_group(
  account_id=test_account_id,
  name='Managers',
  description='Group for managers'
).get_result()

print(json.dumps(group, indent=2))

createAccessGroupOptions := iamAccessGroupsService.NewCreateAccessGroupOptions(testAccountID, "Managers")
createAccessGroupOptions.SetDescription("Group for managers")
group, response, err := iamAccessGroupsService.CreateAccessGroup(createAccessGroupOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(group, "", "  ")
fmt.Println(string(b))

Zur Unterscheidung von Zugriffsgruppen im Konto ist ein eindeutiger Name erforderlich.

Zugriffsgruppe mittels Terraform erstellen

Verwenden Sie die folgenden Schritte, um mit Terraform Zugriffsgruppen zu erstellen:

  1. Erstellen Sie ein Argument in Ihrer main.tf Datei. Im folgenden Beispiel wird eine Zugriffsgruppe unter Verwendung der Ressource ibm_iam_access_group erstellt; hierbei steht name für einen eindeutigen Namen zur Kennzeichnung der Zugriffsgruppe.

    resource "ibm_iam_access_group" "accgrp" {
 name        = "test"
 description = "New access group"
}

    Sie können in der Option description ebenfalls eine Beschreibung der Zugriffsgruppe angeben. Weitere Informationen finden Sie in der Argument-Referenz auf der Terraform Identity and Access Management(IAM) Seite.

Rationalisieren Sie die Zugriffsverwaltung, indem Sie Benutzer und Service-IDs mit den Terraform IBM Modulen(TIM) für IAM Access Groups gruppieren.

  1. Nachdem Sie Ihre Konfigurationsdatei erstellt haben, initialisieren Sie die Terraform CLI. Weitere Informationen finden Sie unter Initialisierung von Arbeitsverzeichnissen.

    terraform init

  2. Bereitstellung der Ressourcen aus der Datei main.tf. Weitere Informationen finden Sie unter Bereitstellung der Infrastruktur mit Terraform.

    1. Führen Sie terraform plan aus, um einen Terraform-Ausführungsplan zu erstellen und eine Vorschau der vorgeschlagenen Aktionen zu erhalten.

      terraform plan

    2. Führen Sie terraform apply aus, um die im Plan definierten Ressourcen zu erstellen.

      terraform apply

Zugriffsberechtigungen für eine Gruppe in der Konsole zuweisen

Nachdem Sie Ihre Gruppe mit Benutzern und Service-IDs eingerichtet haben, können Sie der Gruppe eine gemeinsame Zugriffsrichtlinie zuweisen. Denken Sie daran, dass alle Richtlinien, die Sie für die Gruppe festlegen, für alle Entitäten in der Gruppe gelten. Durch die Zuweisung von Zugriffsrichtlinien zu einer Zugriffsgruppe wird beispielsweise die Fähigkeit, Zugriff auf Benutzer, Dienst-IDs oder vertrauenswürdige Profile zu gewähren oder zu entziehen, an die Administratoren dieser Zugriffsgruppe delegiert.

Der Administratorzugriff auf alle Funktionen des Kontos umfasst auch die Möglichkeit, anderen Benutzern mit der Administratorrolle den Zugriff zu entziehen.

Gehen Sie wie folgt vor, um einer Gruppe in der Konsole Zugang zu gewähren:

  1. Klicken Sie in der IBM Cloud-Konsole auf Verwalten > Zugriff (IAM) und wählen Sie Zugriffsgruppen aus.

  2. Wählen Sie für die Gruppe, der Sie Zugriff zuweisen wollen, das Symbol Aktionen Symbol 'Aktionen' aus und klicken Sie auf Zugriff zuweisen.

  3. Sie können nur Zugriff auf Ressourcen zuweisen, die Sie verwalten. Sie müssen mindestens eine Zugriffsoption zuweisen. Bei allen nicht hinzugefügten und nicht konfigurierten Zugriffsoptionen wird der Standardwert Kein Zugriff zugewiesen. Abhängig von den Optionen, zu deren Verwaltung Sie berechtigt sind, können Sie folgende Zugriffstypen zuweisen:

    • Eine Gruppe von Diensten, wie z. B. alle identitäts- und zugriffsfähigen Dienste, alle Account Management-Dienste oder alle IAM Account Management-Dienste.
    • Eine besondere Dienstleistung

  4. Als Nächstes können Sie den Zugriff auf alle Ressourcen oder auf bestimmte Ressourcen anhand von ausgewählten Ressourcenattributen festlegen (zum Beispiel Zugriffsmanagementtags, Standort oder Ressourcengruppe).

  5. Wählen Sie alle zutreffenden Rollen aus. Um anzuzeigen, welche Aktionen den einzelnen Rollen zugeordnet sind, können Sie auf die Nummern klicken, die neben den einzelnen Rollen aufgelistet sind. Einige Services unterstützen die Verwendung erweiterter Operatoren für die Erteilung des Zugriffs auf Ressourcen, die bestimmte Namenskonventionen erfüllen. Weitere Informationen hierzu finden Sie in Zugriffsberechtigungen mithilfe von Platzhalterrichtlinien zuweisen.

  6. Klicken Sie auf Überprüfung.

  7. Klicken Sie auf Hinzufügen, um die Richtlinienkonfiguration zu Ihrer Richtlinienzusammenfassung hinzuzufügen.

  8. Klicken Sie auf Zuweisen.

Sie können den Zugriff auch mithilfe von Zugriffsmanagementtags zuweisen. Weitere Informationen finden Sie unter Zugriff auf Ressourcen mithilfe von Tags steuern.

Einer Gruppe Zugriffsberechtigungen über die Befehlszeilenschnittstelle (CLI) zuweisen

Wenn Sie eine Zugriffsgruppenrichtlinie mithilfe der Befehlszeilenschnittstelle erstellen möchten, können Sie den Befehl ibmcloud iam access-group-policy-create verwenden.

ibmcloud iam access-group-policy-create GROUP_NAME {-f, --file @JSON_FILE | --roles ROLE_NAME1,ROLE_NAME2... [--service-name SERVICE_NAME] [--service-instance SERVICE_INSTANCE] [--region REGION] [--resource-type RESOURCE_TYPE] [--resource RESOURCE] [--resource-group-name RESOURCE_GROUP_NAME] [--resource-group-id RESOURCE_GROUP_ID]}

Einer Gruppe Zugriffsberechtigungen über die Anwendungsprogrammierschnittstelle (API) zuweisen

Sie können einer Gruppe programmatisch Zugriff zuweisen, indem Sie die IBM Cloud® Identity and Access Management(IAM)Policy Management API aufrufen, wie in der folgenden Beispielanforderung gezeigt. In diesem Beispiel wird einer Zugriffsgruppe die Rolle eines Editor für eine Serviceinstanz zugewiesen:

curl -X POST 'https://iam.cloud.ibm.com/v1/policies' \
-H 'Authorization: Bearer $TOKEN' \
-H 'Content-Type: application/json' \
-d '{
  "type": "access",
  "description": "Editor role for SERVICE_NAME's RESOURCE_NAME",
  "subjects": [
    {
      "attributes": [
        {
          "name": "access_group_id",
          "value": "exampleAccessGroupId"
        }
      ]
    }'
  ],
  "roles":[
    {
      "role_id": "crn:v1:bluemix:public:iam::::role:Editor"
    }
  ],
  "resources":[
    {
      "attributes": [
        {
          "name": "accountId",
          "value": "$ACCOUNT_ID"
        },
        {
          "name": "serviceName",
          "value": "$SERVICE_NAME"
        },
        {
          "name": "resource",
          "value": "$RESOURCE_NAME",
          "operator": "stringEquals"
        }
      ]
    }
  ]
}'

SubjectAttribute subjectAttribute = new SubjectAttribute.Builder()
        .name("access_group_id")
        .value(exampleAccessGroupId)
        .build();

PolicySubject policySubjects = new PolicySubject.Builder()
        .addAttributes(subjectAttribute)
        .build();

PolicyRole policyRoles = new PolicyRole.Builder()
        .roleId("crn:v1:bluemix:public:iam::::role:Editor")
        .build();

ResourceAttribute accountIdResourceAttribute = new ResourceAttribute.Builder()
        .name("accountId")
        .value(exampleAccountId)
        .operator("stringEquals")
        .build();

ResourceAttribute serviceNameResourceAttribute = new ResourceAttribute.Builder()
        .name("serviceType")
        .value("service")
        .operator("stringEquals")
        .build();

PolicyResource policyResources = new PolicyResource.Builder()
        .addAttributes(accountIdResourceAttribute)
        .addAttributes(serviceNameResourceAttribute)
        .build();

CreatePolicyOptions options = new CreatePolicyOptions.Builder()
        .type("access")
        .subjects(Arrays.asList(policySubjects))
        .roles(Arrays.asList(policyRoles))
        .resources(Arrays.asList(policyResources))
        .build();

Response<Policy> response = service.createPolicy(options).execute();
Policy policy = response.getResult();

System.out.println(policy);

const policySubjects = [
  {
    attributes: [
      {
        name: 'access_group_id',
        value: exampleAccessGroupId,
      },
    ],
  },
];
const policyRoles = [
  {
    role_id: 'crn:v1:bluemix:public:iam::::role:Editor',
  },
];
const accountIdResourceAttribute = {
  name: 'accountId',
  value: exampleAccountId,
  operator: 'stringEquals',
};
const serviceNameResourceAttribute = {
  name: 'serviceType',
  value: 'service',
  operator: 'stringEquals',
};
const policyResources = [
  {
    attributes: [accountIdResourceAttribute, serviceNameResourceAttribute],
  },
];
const params = {
  type: 'access',
  subjects: policySubjects,
  roles: policyRoles,
  resources: policyResources,
};

iamPolicyManagementService.createPolicy(params)
  .then(res => {
    examplePolicyId = res.result.id;
    console.log(JSON.stringify(res.result, null, 2));
  })
  .catch(err => {
    console.warn(err)
  });

policy_subjects = PolicySubject(
  attributes=[SubjectAttribute(name='access_group_id', value=exampleAccessGroupId)])
policy_roles = PolicyRole(
  role_id='crn:v1:bluemix:public:iam::::role:Editor')
account_id_resource_attribute = ResourceAttribute(
  name='accountId', value=example_account_id)
service_name_resource_attribute = ResourceAttribute(
  name='serviceType', value='service')
policy_resources = PolicyResource(
  attributes=[account_id_resource_attribute,
        service_name_resource_attribute])

policy = iam_policy_management_service.create_policy(
  type='access',
  subjects=[policy_subjects],
  roles=[policy_roles],
  resources=[policy_resources]
).get_result()

print(json.dumps(policy, indent=2))

subjectAttribute := &iampolicymanagementv1.SubjectAttribute{
  Name:  core.StringPtr("access_group_id"),
  Value: &exampleAccessGroupId,
}
policySubjects := &iampolicymanagementv1.PolicySubject{
  Attributes: []iampolicymanagementv1.SubjectAttribute{*subjectAttribute},
}
policyRoles := &iampolicymanagementv1.PolicyRole{
  RoleID: core.StringPtr("crn:v1:bluemix:public:iam::::role:Editor"),
}
accountIDResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
  Name:     core.StringPtr("accountId"),
  Value:    core.StringPtr(exampleAccountID),
  Operator: core.StringPtr("stringEquals"),
}
serviceNameResourceAttribute := &iampolicymanagementv1.ResourceAttribute{
  Name:     core.StringPtr("serviceType"),
  Value:    core.StringPtr("service"),
  Operator: core.StringPtr("stringEquals"),
}
policyResources := &iampolicymanagementv1.PolicyResource{
  Attributes: []iampolicymanagementv1.ResourceAttribute{
    *accountIDResourceAttribute, *serviceNameResourceAttribute}
}

options := iamPolicyManagementService.NewCreatePolicyOptions(
  "access",
  []iampolicymanagementv1.PolicySubject{*policySubjects},
  []iampolicymanagementv1.PolicyRole{*policyRoles},
  []iampolicymanagementv1.PolicyResource{*policyResources},
)

policy, response, err := iamPolicyManagementService.CreatePolicy(options)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(policy, "", "  ")
fmt.Println(string(b))

Sie können den Zugang zu einer Gruppe von Diensten zuweisen. Um den Zugriff auf die Dienste "All Identity and Access Enabled" zuzuweisen, geben Sie serviceType für das Attribut name an und verwenden Sie das Attribut value service. Um den Zugriff auf alle Account Management-Dienste zuzuweisen, geben Sie serviceType für das Attribut name an und verwenden Sie value platform_service. Um den Zugriff auf die Untergruppe der Kontoverwaltungsdienste Alle IAM-Kontoverwaltungsdienste zuzuweisen, geben Sie service_group_id für das Attribut name an, und verwenden Sie die value IAM.

Zugriffsberechtigung mithilfe von Terraform zu einer Gruppe zuweisen

Nachdem Sie Ihre Gruppe eingerichtet haben, verwenden Sie die folgenden Schritte, um ihr mithilfe von Terraform Zugriff zu gewähren.

  1. Erstellen Sie ein Argument in Ihrer main.tf Datei. In den folgenden Beispielen wird eine IAM-Richtlinie erstellt, die Mitgliedern der Zugriffsgruppe die IAM-Viewer-Plattformrolle für alle für IAM aktivierten Services mithilfe der Ressource ibm_iam_access_group_policy gewährt. Sie müssen über eine vorhandene IAM-ID einer Zugriffsgruppe verfügen, um den Vorgang abschließen zu können.

    resource "ibm_iam_access_group" "accgrp" {
 name = "test"
}

    resource "ibm_iam_access_group_policy" "policy" {
 access_group_id = ibm_iam_access_group.accgrp.id
 roles           = ["Viewer"]
}

    Weitere Informationen finden Sie in der Argument-Referenz auf der Terraform Identity and Access Management(IAM) Seite.

Sie können auch das IAM Access Groups-Modul verwenden, um Zugriffsgruppen und Richtlinien in großem Umfang zu verwalten. Das folgende Beispiel zeigt die Verwendung des Moduls:

module "access_group" {
  source  = "terraform-ibm-modules/iam-access-group/ibm"
  version = "latest"

  access_group_name        = "my-access-group"
  access_group_description = "Access group for team members"

  policies = [
    {
      roles = ["Viewer"]
      resources = [{
        service = "cloud-object-storage"
      }]
    }
  ]
}

Weitere Informationen über Terraform IBM Module finden Sie unter Über Terraform IBM Module.

  1. Nachdem Sie Ihre Konfigurationsdatei erstellt haben, initialisieren Sie die Terraform CLI. Weitere Informationen finden Sie unter Initialisierung von Arbeitsverzeichnissen.

    terraform init

  2. Bereitstellung der Ressourcen aus der Datei main.tf. Weitere Informationen finden Sie unter Bereitstellung der Infrastruktur mit Terraform.

    1. Führen Sie terraform plan aus, um einen Terraform-Ausführungsplan zu erstellen und eine Vorschau der vorgeschlagenen Aktionen zu erhalten.

      terraform plan

    2. Führen Sie terraform apply aus, um die im Plan definierten Ressourcen zu erstellen.

      terraform apply

Hinzufügen von Mitgliedern zu einer Zugangsgruppe in der Konsole

Mitglieder können Benutzer, Dienst-IDs und vertrauenswürdige Profile sein.

  1. Klicken Sie in der IBM Cloud®-Konsole auf Verwalten > Zugriff (IAM) und wählen Sie Zugriffsgruppen aus.

  2. Klicken Sie auf die von Ihnen erstellte Zugangsgruppe.

  3. Mitglieder hinzufügen.

    1. Klicken Sie auf Benutzer hinzufügen.
    2. Klicken Sie auf Service-IDs > Service-IDs hinzufügen.
    3. Klicken Sie auf Vertrauenswürdige Profile > Vertrauenswürdige Profile hinzufügen.

    Wenn Sie die Schaltfläche zum Hinzufügen von Mitgliedern nicht sehen, haben Sie möglicherweise keinen Zugang. Überprüfen Sie die Zugangsvoraussetzungen und wenden Sie sich an Ihren Kontoverwalter, um Zugang zu erhalten.

  4. Wählen Sie die Benutzer, Dienst-IDs oder vertrauenswürdigen Profile aus, die Sie der Gruppe hinzufügen möchten, und klicken Sie auf Zur Gruppe hinzufügen.

Mitglieder, die Sie der Gruppe hinzufügen, können die Zugriffsebene nutzen, die Sie der Gruppe zuweisen.

Hinzufügen von Mitgliedern zu einer Zugriffsgruppe mit Hilfe der CLI

Mitglieder können Benutzer, Dienst-IDs und vertrauenswürdige Profile sein. Mitglieder, die Sie der Gruppe hinzufügen, können die Zugriffsebene nutzen, die Sie der Gruppe zuweisen.

  1. Rufen Sie die Benutzer, Dienst-IDs oder vertrauenswürdigen Profile in Ihrem Konto ab. Beachten Sie die Details, die für das Mitglied, das Sie der Zugriffsgruppe hinzufügen möchten, zurückgegeben werden.

    Erhalten Sie alle Benutzer:

    ibmcloud account users [-c, --account-id ACCOUNT_ID]

    Alle Dienst-IDs auflisten:

    ibmcloud iam service-ids [--uuid]

    Erhalten Sie alle vertrauenswürdigen Profile:

    ibmcloud iam trusted-profiles [--id | --output FORMAT] [-q, --quiet]

  2. Fügen Sie der Zugriffsgruppe Mitglieder hinzu:

    Verwenden Sie den Befehl ibmcloud iam access-group-user-add, um Benutzer zu einer Zugriffsgruppe hinzuzufügen. Im folgenden Beispiel wird der Benutzer name@example.com über die Befehlszeilenschnittstelle zur Zugriffsgruppe example_group hinzugefügt.

    ibmcloud iam access-group-user-add example_group name@example.com

    Verwenden Sie den Befehl ibmcloud iam access-group-service-id-add, um Service-IDs zu einer Zugriffsgruppe hinzuzufügen. Das folgende Beispiel fügt die Service-ID example-service zur Zugriffsgruppe example_group hinzu:

    ibmcloud iam access-group-service-id-add example_group example-service

    Verwenden Sie den Befehl ibmcloud iam access-group-trusted profile-add, um vertrauenswürdige Profile zu einer Zugriffsgruppe hinzuzufügen. Das folgende Beispiel fügt die Service-ID PROFILE_ID zur Zugriffsgruppe example_group hinzu:

    ibmcloud iam access-group-trusted-profile-add GROUP_NAME (PROFILE_NAME | PROFILE_ID) [PROFILE_NAME2 | PROFILE_ID2...] [--output FORMAT] [-q, --quiet]

Hinzufügen von Mitgliedern zu einer Zugangsgruppe über die API

Mitglieder können Benutzer, Dienst-IDs und vertrauenswürdige Profile sein.

  1. Listen Sie die Benutzer, Dienst-IDs oder vertrauenswürdigen Profile in Ihrem Konto auf, wie in der folgenden Beispielanforderung gezeigt. Notieren Sie sich die IBMid, die Dienst-ID oder die vertrauenswürdige Profil-ID, die für das Mitglied, das Sie der Zugriffsgruppe hinzufügen möchten, zurückgegeben wird.

    Benutzer auflisten:

    curl -X GET https://user-management.cloud.ibm.com/v2/accounts/987d4cfd77b04e9b9e1a6asdcc861234/users -H 'Authorization: Bearer <IAM_TOKEN>'

    ListUsersOptions listUsersOptions = new ListUsersOptions.Builder()
  .accountId(accountId)
  .build();

UsersPager pager = new UsersPager(userManagementService, listUsersOptions);
List<UserProfile> allResults = new ArrayList<>();
while (pager.hasNext()) {
  List<UserProfile> nextPage = pager.getNext();
  allResults.addAll(nextPage);
}

System.out.println(GsonSingleton.getGson().toJson(allResults));

    const params = {
  accountId: accountId,
};

const allResults = [];
try {
  const pager = new UserManagementV1.UsersPager(userManagementService, params);
  while (pager.hasNext()) {
    const nextPage = await pager.getNext();
    expect(nextPage).not.toBeNull();
    allResults.push(...nextPage);
  }
  console.log(JSON.stringify(allResults, null, 2));
} catch (err) {
  console.warn(err);
}

    all_results = []
pager = UsersPager(
  client=user_management_service,
  account_id=account_id,
)
while pager.has_next():
  next_page = pager.get_next()
  assert next_page is not None
  all_results.extend(next_page)

print(json.dumps(all_results, indent=2))

    listUsersOptions := &usermanagementv1.ListUsersOptions{
  AccountID: &accountID,
}

pager, err := userManagementService.NewUsersPager(listUsersOptions)
if err != nil {
  panic(err)
}

var allResults []usermanagementv1.UserProfile
for pager.HasNext() {
  nextPage, err := pager.GetNext()
  if err != nil {
    panic(err)
  }
  allResults = append(allResults, nextPage...)
}
b, _ := json.MarshalIndent(allResults, "", "  ")
fmt.Println(string(b))

    Dienst-IDs auflisten:

    curl -X GET 'https://iam.cloud.ibm.com/v1/serviceids?account_id=ACCOUNT_ID&name=My-serviceID' -H 'Authorization: Bearer TOKEN' -H 'Content-Type: application/json'

    ListServiceIdsOptions listServiceIdsOptions = new ListServiceIdsOptions.Builder()
    .accountId(accountId)
    .name(serviceIdName)
    .build();

Response<ServiceIdList> response = service.listServiceIds(listServiceIdsOptions).execute();
ServiceIdList serviceIdList = response.getResult();

System.out.println(serviceIdList);

    const params = {
  accountId: accountId,
  name: serviceIdName,
};

try {
  const res = await iamIdentityService.listServiceIds(params)
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

    service_id_list = iam_identity_service.list_service_ids(
  account_id=account_id, name=serviceid_name
).get_result()

print(json.dumps(service_id_list, indent=2))

    listServiceIdsOptions := iamIdentityService.NewListServiceIdsOptions()
listServiceIdsOptions.SetAccountID(accountID)
listServiceIdsOptions.SetName(serviceIDName)

serviceIDList, response, err := iamIdentityService.ListServiceIds(listServiceIdsOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(serviceIDList, "", "  ")
fmt.Println(string(b))

    Liste vertrauenswürdiger Profile:

    curl -X GET 'https://iam.cloud.ibm.com/v1/profiles?account_id=ACCOUNT_ID' -H 'Authorization: Bearer TOKEN' -H 'Accept: application/json'

    ListProfilesOptions listProfilesOptions = new ListProfilesOptions.Builder()
    .accountId(accountId)
    .includeHistory(false)
    .build();

Response<TrustedProfilesList> response = service.listProfiles(listProfilesOptions).execute();
TrustedProfilesList profiles = response.getResult();

System.out.println(profiles);

    const params = {
  accountId: accountId,
  includeHistory: false,
};

try {
  const res = await iamIdentityService.listProfiles(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

    profile_list = iam_identity_service.list_profiles(account_id=account_id, include_history=True).get_result()

print(json.dumps(profile_list, indent=2))

    listProfilesOptions := iamIdentityService.NewListProfilesOptions(accountID)
listProfilesOptions.SetIncludeHistory(false)

trustedProfiles, response, err := iamIdentityService.ListProfiles(listProfilesOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(trustedProfiles, "", "  ")
fmt.Println(string(b))

  2. Fügen Sie der Zugriffsgruppe Mitglieder hinzu, indem Sie die IAM-API für Zugriffsgruppen aufrufen, wie in der folgenden Beispielanforderung gezeigt.

    Der Typ des Mitglieds muss user, service oder profile sein.

    curl -X PUT --location --header "Authorization: Bearer {iam_token}" --header "Accept: application/json" --header "Content-Type: application/json" --data '{ "members": [ { "iam_id": "IBMid-user1", "type": "user" }, { "iam_id": "iam-ServiceId-123", "type": "service" }, { "iam_id": "iam-Profile-123", "type": "profile" } ] }' "{base_url}/v2/groups/{access_group_id}/members"

    AddGroupMembersRequestMembersItem member1 = new AddGroupMembersRequestMembersItem.Builder()
  .iamId("IBMid-user1")
  .type("user")
  .build();
AddGroupMembersRequestMembersItem member2 = new AddGroupMembersRequestMembersItem.Builder()
  .iamId("iam-ServiceId-123")
  .type("service")
  .build();
  AddGroupMembersRequestMembersItem member3 = new AddGroupMembersRequestMembersItem.Builder()
  .iamId(testProfileId)
  .type("profile")
  .build();
AddMembersToAccessGroupOptions addMembersToAccessGroupOptions = new AddMembersToAccessGroupOptions.Builder()
  .accessGroupId(testGroupId)
  .addMembers(member1)
  .addMembers(member2)
  .addMembers(member3)
  .build();
Response<AddGroupMembersResponse> response = iamAccessGroupsService.addMembersToAccessGroup(addMembersToAccessGroupOptions).execute();
AddGroupMembersResponse addGroupMembersResponse = response.getResult();

System.out.println(addGroupMembersResponse);

    const groupMember1 = {
  iam_id: 'IBMid-user1',
  type: 'user',
};
const groupMember2 = {
  iam_id: 'iam-ServiceId-123',
  type: 'service',
};
var groupMember3 = {
  iam_id: profileId,
  type: 'profile',
}

const params = {
  accessGroupId: testGroupId,
  members: [groupMember1, groupMember2, groupMember3],
};

try {
  const res = await iamAccessGroupsService.addMembersToAccessGroup(params);
  console.log(JSON.stringify(res.result, null, 2));
} catch (err) {
  console.warn(err);
}

    member1 = AddGroupMembersRequestMembersItem(iam_id='IBMid-user1', type='user')
member2 = AddGroupMembersRequestMembersItem(iam_id='iam-ServiceId-123', type='service')
member3 = AddGroupMembersRequestMembersItem(iam_id=test_profile_id, type='profile')
members = [member1, member2, member3]

response = iam_access_groups_service.add_members_to_access_group(
  access_group_id=test_group_id,
  members=members,
)
add_group_members_response = response.get_result()

print(json.dumps(add_group_members_response, indent=2))

    groupMembers := []iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
  iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
    IamID: core.StringPtr("IBMid-user1"),
    Type:  core.StringPtr("user"),
  },
  iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
    IamID: core.StringPtr("iam-ServiceId-123"),
    Type:  core.StringPtr("service"),
  },
  iamaccessgroupsv2.AddGroupMembersRequestMembersItem{
    IamID: core.StringPtr(testProfileID),
    Type:  core.StringPtr("profile"),
  },
}

addMembersToAccessGroupOptions := iamAccessGroupsService.NewAddMembersToAccessGroupOptions(
  accessGroupIDLink,
)
addMembersToAccessGroupOptions.SetMembers(groupMembers)

addGroupMembersResponse, response, err := iamAccessGroupsService.AddMembersToAccessGroup(addMembersToAccessGroupOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(addGroupMembersResponse, "", "  ")
fmt.Println(string(b))

Mitglieder, die Sie der Gruppe hinzufügen, können die Zugriffsebene nutzen, die Sie der Gruppe zuweisen.

Hinzufügen von Mitgliedern zu einer Zugangsgruppe mithilfe von Terraform

Mitglieder können Benutzer, Dienst-IDs und vertrauenswürdige Profile sein.

  1. Erstellen Sie ein Argument in Ihrer main.tf Datei. Das folgende Beispiel fügt eine Dienst-ID, ein vertrauenswürdiges Profil und einen Benutzer mit der ID user@ibm.com zu einer Zugriffsgruppe hinzu.

    resource "ibm_iam_access_group_members" "accgroupmem" {
  access_group_id = ibm_iam_access_group.accgroup.id
  ibm_ids         = ["user@ibm.com"]
  iam_service_ids = [ibm_iam_service_id.serviceID.id]
  iam_profile_ids = [ibm_iam_trusted_profile.profileID.id]
}

Verwalten Sie die Gruppenmitgliedschaft programmatisch mit dem IAM Access Groups-Modul für die automatische Bereitstellung von Benutzern. Erkunden Sie Terraform IBM Module für die Mitgliederverwaltung.

  1. Nachdem Sie Ihre Konfigurationsdatei erstellt haben, initialisieren Sie die Terraform CLI. Weitere Informationen finden Sie unter Initialisierung von Arbeitsverzeichnissen.

    terraform init

  2. Bereitstellung der Ressourcen aus der Datei main.tf. Weitere Informationen finden Sie unter Bereitstellung der Infrastruktur mit Terraform.

    1. Führen Sie terraform plan aus, um einen Terraform-Ausführungsplan zu erstellen und eine Vorschau der vorgeschlagenen Aktionen zu erhalten.

      terraform plan

    2. Führen Sie terraform apply aus, um die im Plan definierten Ressourcen zu erstellen.

      terraform apply

Mitglieder, die Sie der Gruppe hinzufügen, können die Zugriffsebene nutzen, die Sie der Gruppe zuweisen.