nerdgraph-manage-groups.mdx

title	tags	metaDescription	freshnessValidatedDate	translationType
Tutorial de NerdGraph: Administrar grupos de usuarios	APIs NerdGraph	How to use New Relic's NerdGraph API to manage user groups and query information about groups.	never	machine

Puede utilizar nuestra API NerdGraph para ver y administrar grupos de usuarios y a qué pueden acceder esos grupos. Para saber cómo hacer esto en la UI, consulte los documentos de la UI de administración de usuarios.

Para usar NerdGraph para crear un usuario y ver su información, consulte Administrar usuario con NerdGraph.

Requisitos [#requirements]

Algunos requisitos para gestionar usuarios y grupos a través de NerdGraph:

• Se requiere la versión Pro o Enterprise para personalizar grupos y roles de usuarios

• Si está utilizando el aprovisionamiento SCIM: para ese dominio de autenticación, no puede crear grupos ni agregar usuarios a los grupos, porque sus grupos y usuarios se administran a través de SCIM.

• Debes ser un usuario de nuestro modelo de usuario más nuevo. Otros requisitos relacionados con los permisos:

  • Tipo de usuario requerido: usuario principal o usuario de plataforma completa
  • Configuración de administración requerida: Organization settings o Authentication domain settings

Antes de que empieces [#concepts]

Antes de usar NerdGraph para administrar usuarios:

• Asegúrese de tener una comprensión adecuada de nuestros conceptos de gestión de usuarios.
• Si aún no lo ha hecho, le sugerimos que consulte la UI Access management para comprender mejor cómo funcionan los grupos y el acceso de los usuarios, y comprender los grupos que ya existen. Antes de hacer esto, le recomendamos crear un plan para el acceso del grupo que necesita crear: aquí hay un ejemplo de hoja de cálculo de planificación.
• Tenga en cuenta que el explorador NerdGraph tiene documentos integrados que definen los campos utilizados en estas solicitudes.
• Tenga en cuenta que puede realizar un seguimiento de los cambios en su cuenta New Relic.

Flujo de trabajo sugerido para la creación de grupos. [#flow]

Puede utilizar estas consultas y mutaciones de varias maneras y en varios órdenes, pero aquí hay un flujo de trabajo común para configurar grupos:

1. Consulta la información de tu usuario y los roles disponibles: este puede ser un primer lugar útil para comenzar a asegurarte de comprender qué usuario tienes en New Relic y los roles disponibles. Si recién está comenzando, es posible que aún no haya agregado un usuario y que solo tenga nuestros roles estándar.
2. Opcional: crear un grupo nuevo: Not available if using SCIM provisioning. Puede utilizar grupos existentes o crear un grupo nuevo. Después de crear un grupo, debes otorgarle acceso a roles y cuentas. Tenga en cuenta que un grupo, por sí solo, no otorga ningún acceso a los usuarios de ese grupo: solo cuando tiene un rol y una cuenta asignados, el usuario puede acceder a New Relic.
3. Otorgar acceso a un grupo: esto es lo que asigna a los grupos acceso a roles y cuentas.

Cuando haya terminado, si ya hay usuarios en el grupo que ha creado y ese grupo tiene acceso a al menos una función y cuenta, deberían tener acceso en unos minutos (aunque para las cuentas New Relic de la región de la UE, esto puede tomar hasta 20 minutos aproximadamente). Si su usuario aún no está en ese grupo (lo cual sería cierto si acaba de crear un grupo nuevo), puede agregar un usuario a ese grupo.

Grupos de consulta [#query-groups]

A continuación se muestra un ejemplo de consulta de grupos existentes en un dominio de autenticación determinado:

{
  actor {
    organization {
      userManagement {
        authenticationDomains(id: "YOUR_AUTHENTICATION_DOMAIN_ID") {
          authenticationDomains {
            groups {
              groups {
                displayName
                id
              }
            }
          }
        }
      }
    }
  }
}

Consultar roles existentes [#query-roles]

A continuación se muestra un ejemplo de cómo devolver información sobre roles:

{
  actor {
    organization {
      authorizationManagement {
        authenticationDomains {
          authenticationDomains {
            groups {
              groups {
                roles {
                  roles {
                    accountId
                    displayName
                    id
                    name
                    organizationId
                    type
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Aquí hay un resultado de ejemplo:

{
  "data": {
    "actor": {
      "organization": {
        "authorizationManagement": {
          "authenticationDomains": {
            "authenticationDomains": [
              {
                "groups": {
                  "groups": [
                    {
                      "roles": {
                        "roles": [
                          {
                            "accountId": "account-id",
                            "displayName": "name",
                            "id": "id",
                            "name": "role-name",
                            "organizationId": null,
                            "type": "role-type"
                          },
                          {
                            "accountId":null,
                            "displayName": "name",
                            "id": "id",
                            "name": "role-name",
                            "organizationId": "organization-id",
                            "type": "role-type"
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

Consulta usuario [#query-users]

Consultar información del usuario [#query-user-info]

A continuación se muestra un ejemplo de consulta de información sobre su usuario:

{
  actor {
    organization {
      userManagement {
        authenticationDomains {
          authenticationDomains {
            groups {
              groups {
                users {
                  users {
                    id
                    email
                    name
                    timeZone
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Aquí hay un resultado de ejemplo:

{
  "data": {
    "actor": {
      "organization": {
        "userManagement": {
          "authenticationDomains": {
            "authenticationDomains": [
              {
                "groups": {
                  "groups": [
                    {
                      "users": {
                        "users": [
                          {
                            "email": "example@newrelic.com",
                            "id": "123456789",
                            "name": "Example Relic",
                            "timeZone": "Etc/UTC"
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

Consulta las membresías del grupo de tus usuarios [#query-user-groups]

A continuación se muestra un ejemplo de consulta de los grupos a los que pertenece su usuario:

{
  actor {
    organization {
      userManagement {
        authenticationDomains {
          authenticationDomains {
            users {
              users {
                groups {
                  groups {
                    displayName
                  }
                }
                email
              }
            }
          }
        }
      }
    }
  }
}

Aquí hay un ejemplo de respuesta:

{
  "data": {
    "actor": {
      "organization": {
        "userManagement": {
          "authenticationDomains": {
            "authenticationDomains": [
              {
                "users": {
                  "users": [
                    {
                      "email": "pete@example.com",
                      "groups": {
                        "groups": [
                          {
                            "displayName": "Admin"
                          },
                          {
                            "displayName": "Basic Sub Account"
                          }
                        ]
                      }
                    },

Crear un rol [#create-role]

Antes de crear un rol personalizado, debes identificar las licencias que deseas asignarle.

Recuperar los ID de permisos

Utilice la siguiente consulta para recuperar la lista de permisos con alcance de cuenta:

query {
  customerAdministration {
    permissions {
      items {
        category
        feature
        id
        product
        subsetIds
      }
      nextCursor
    }
  }
}

Para los permisos con alcance a una organización, ejecute la siguiente consulta en su lugar:

query {
  customerAdministration {
    permissions(filter: {scope: {eq: "organization"}}) {
      items {
        category
        feature
        id
        product
        subsetIds
      }
      nextCursor
    }
  }
}

Tenga en cuenta los siguientes campos:

• items: Una matriz de objetos de licencia, cada uno de los cuales contiene el siguiente atributo:

  • category: (Cadena) La categoría o agrupación a la que pertenece la licencia.
  • feature: (Cadena) La característica específica con la que está asociado la licencia.
  • id: (Cadena) Un identificador único para cada licencia.
  • product: (Cadena) El producto al que se aplica la licencia.
  • subsetIds: (Matriz) Una lista de identificadores que representan subconjuntos o licencias relacionadas.

Crear el rol personalizado

Después de tener el identificador único de cada permiso que desea asignar al nuevo rol, utilice la siguiente mutación para crear un rol:

mutation {
  customRoleCreate(
    container: {
      id: "YOUR_ORGANIZATION_ID"
      type: "ORGANIZATION"
    }
    name: "MY CUSTOM ROLE"
    permissionIds: [1, 2, 3]
    scope: "account"
  ) {
    id
  }
}

Parámetros

• container:

  • id: (Cadena) El identificador único de su organización. Reemplace YOUR_ORGANIZATION_ID con su ID de organización real.
  • type: (Cadena) El tipo de contenedor. Actualmente, el único tipo admitido es "ORGANIZATION".
  • name: (Cadena) El nombre asignado al rol personalizado. Ejemplo: "MY CUSTOM ROLE".

• permissionIds: (Array) Una lista de ID de permisos que representan las capacidades asignadas al rol personalizado. Utilice los ID recuperados de la consulta de permisos anterior.

• scope: (Cadena) El nivel en el que se aplican las licencias del rol. En esta instancia, el alcance es "ACCOUNT".

Respuesta

• id: Devuelve el ID único del rol personalizado recién creado.

  * Reemplace `YOUR_ORGANIZATION_ID` con el ID de su organización específica antes de ejecutar la mutación. * Reemplace el ejemplo `permissionIds: [1, 2, 3]` con los ID de permisos reales que recuperó de la consulta de permisos.

Actualizar rol [#update-role]

A continuación se muestra un ejemplo de actualización de un rol.

mutation {
  customRoleUpdate(
    id: ROLE_ID
    name: "MY NEW CUSTOM ROLE NAME"
    permissionIds: [4,5,6] 
  ) {
    id
  }
}

Parámetros

• id: El identificador único del rol personalizado que desea modificar. Reemplace ROLE_ID con el ID real del rol.
• name: El nuevo nombre que desea asignar al rol personalizado. En este ejemplo, es MY NEW CUSTOM ROLE NAME.
• permissionIds:Una matriz de identificaciones de licencias que desea asignar a esta función. Cerciorar de que estos ID sean válidos y correspondan a las licencias que desea implementar.

Eliminar un rol [#delete-role]

A continuación se muestra un ejemplo de cómo eliminar un rol:

mutation {
  customRoleDelete(
    id: ROLE_ID 
  ) {
    id
  }
}

Parámetros

• id: El identificador único del rol que desea eliminar. Reemplace ROLE_ID con el ID real del rol que desea eliminar.

Respuesta

• id: Devuelve el ID del rol que fue eliminado, confirmando la ejecución exitosa de la mutación.

Crear un grupo [#create-group]

A continuación se muestra un ejemplo de cómo crear un grupo:

mutation {
  userManagementCreateGroup(
    createGroupOptions: {
      authenticationDomainId: "YOUR_AUTH_DOMAIN_ID"
      displayName: "GROUP_DISPLAY_NAME"
    }
  ) {
    group {
      displayName
      id
    }
  }
}

Respuesta exitosa:

{
  "data": {
    "userManagementCreateGroup": {
      "group": {
        "displayName": "GROUP_DISPLAY_NAME"
	      "id": "GROUP_ID"
      }
    }
  }
}

Actualizar grupo de usuarios [#update-group]

A continuación se muestra un ejemplo de cómo actualizar un grupo.

mutation {
  userManagementUpdateGroup(
    updateGroupOptions: {
      displayName: "YOUR_UPDATED_GROUP_NAME"
      id: "YOUR_GROUP_ID"
    }
  ) {
    group {
      id
      displayName
    }
  }
}

Respuesta para el éxito:

{
  "data": {
    "userManagementUpdateGroup": {
      "group": {
        "displayName": "YOUR_UPDATED_GROUP_NAME",
        "id": "GROUP_ID"
      }
    }
  }
}

Respuesta ante el fracaso:

{
  "data": {
    "userManagementUpdateGroup": null
  },
  "errors": [
    {
      "extensions": {
        "errorClass": "SERVER_ERROR"
      },
      "locations": [
        {
          "column": 3,
          "line": 2
        }
      ],
      "message": "Group could not be found",
      "path": [
        "userManagementUpdateGroup"
      ]
    }
  ]
}

Eliminar un grupo [#delete-group]

A continuación se muestra un ejemplo de eliminación de un grupo:

mutation {
  userManagementDeleteGroup(groupOptions: {id: "YOUR_GROUP_ID"}) {
    group {
      id
    }
  }
}

Respuesta para el éxito:

{
  "data": {
    "userManagementDeleteGroup": {
      "group": {
        "id": "GROUP_ID"
      }
    }
  }
}

Respuesta ante el fracaso:

{
  "data": {
    "userManagementDeleteGroup": null
  },
  "errors": [
    {
      "extensions": {
        "errorClass": "SERVER_ERROR"
      },
      "locations": [
        {
          "column": 3,
          "line": 2
        }
      ],
      "message": "Couldn't find Group with 'id'='ENTERED_GROUP_ID",
      "path": [
        "userManagementDeleteGroup"
      ]
    }
  ]
}

Agregar usuario a grupos [#add-users]

A continuación se muestra un ejemplo de cómo agregar usuarios a grupos:

mutation {
  userManagementAddUsersToGroups(
    addUsersToGroupsOptions: {
      groupIds: [FIRST_GROUP_ID, SECOND_GROUP_ID]
      userIds: [YOUR_USERS_IDS]
    }
  ) {
    groups {
      displayName
      id
    }
  }
}

Respuesta para el éxito:

{
  "data": {
    "userManagementAddUsersToGroups": {
      "groups": [
        {
          "displayName": "GROUP_1_NAME",
          "id": "GROUP_ID_1"
        },
        {
          "displayName": "GROUP_NAME_2",
          "id": "GROUP_ID_2"
        }
      ]
    }
  }
}

Respuesta ante el fracaso:

{
  "data": {
    "userManagementAddUsersToGroups": null
  },
  "errors": [
    {
      "extensions": {
        "errorClass": "SERVER_ERROR"
      },
      "locations": [
        {
          "column": 3,
          "line": 2
        }
      ],
      "message": "The following ids were not found: group_ids: 'NON_EXISTENT_GROUP_ID'",
      "path": [
        "userManagementAddUsersToGroups"
      ]
    }
  ]
}

Eliminar usuario de grupos [#remove-users]

A continuación se muestra un ejemplo de cómo eliminar usuarios de grupos:

mutation {
  userManagementRemoveUsersFromGroups(
    removeUsersFromGroupsOptions: {
      groupIds: [YOUR_GROUP_IDS]
      userIds: [YOUR_USER_IDS]
    }
  ) {
    groups {
      displayName
      id
    }
  }
}

Respuesta para el éxito:

{
  "data": {
    "userManagementRemoveUsersFromGroups": {
      "groups": [
        {
          "displayName": "YOUR_GROUP_NAME",
          "id": "YOUR_GROUP_ID"
        }
      ]
    }
  }
}

Respuesta ante el fracaso:

{
  "data": {
    "userManagementRemoveUsersFromGroups": null
  },
  "errors": [
    {
      "extensions": {
        "errorClass": "SERVER_ERROR"
      },
      "locations": [
        {
          "column": 3,
          "line": 2
        }
      ],
      "message": "The following ids were not found: user_ids: 'NON-EXISTENT_USER_ID'",
      "path": [
        "userManagementRemoveUsersFromGroups"
      ]
    }
  ]
}

Conceder acceso a un grupo [#grant-access]

A continuación se muestra un ejemplo de cómo otorgar acceso a un grupo a una función y una cuenta:

mutation {
  authorizationManagementGrantAccess(
    grantAccessOptions: {
      groupId: "YOUR_GROUP_ID"
      accountAccessGrants: {
        accountId: YOUR_ACCOUNT_ID
        roleId: "YOUR_ROLE_ID"
      }
    }
  ) {
    roles {
      displayName
      accountId
    }
  }
}

Respuesta para el éxito:

{
  "data": {
    "authorizationManagementGrantAccess": {
      "roles": [
        {
          "displayName": "ROLE_NAME_1",
          "id": "ROLE_ID_1"
        },
        {
          "displayName": "ROLE_NAME_2",
          "id": "ROLE_ID_2"
        },
        {
          "displayName": "ROLE_NAME_3",
          "id": "ROLE_ID_3"
        },
        {
          "displayName": "ROLE_NAME_4",
          "id": "ROLE_ID_4"
        }
      ]
    }
  }
}

Respuesta ante el fracaso:

{
  "data": {
    "authorizationManagementGrantAccess": null
  },
  "errors": [
    {
      "extensions": {
        "errorClass": "SERVER_ERROR"
      },
      "locations": [
        {
          "column": 3,
          "line": 2
        }
      ],
      "message": "Validation failed: Role must exist, Role can't be blank, Role scope does not match granted_on type",
      "path": [
        "authorizationManagementGrantAccess"
      ]
    }
  ]
}

Buscar un ID de rol [#role-id]

Para algunos casos de uso, como otorgar acceso a un grupo, es posible que necesite el ID de un rol: el ID numérico que representa ese rol en New Relic.

A continuación se muestran algunos ID de nuestras funciones predeterminadas y configuraciones de administración:

• All product admin: 1254.

• Standard user: 1253.

• Read only: 1252.

• Organization manager setting 1994

  • Read only: 1995

• Authentication domain setting:

  • Manage: 1996
  • Read only: 1997
  • Add users: 14517
  • Read users: 14603

• Group admin: 14516

Aquí hay una consulta para encontrar el ID de un rol personalizado:

{
  actor {
    organization {
      authorizationManagement {
        authenticationDomains(id: "YOUR_AUTHENTICATION_DOMAIN_ID") {
          authenticationDomains {
            groups {
              groups {
                displayName
                id
                roles {
                  roles {
                    roleId
                    name
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Revocar subvenciones del grupo [#revoke-grants]

A continuación se muestra un ejemplo de cómo eliminar el acceso de un grupo:

mutation {
  authorizationManagementRevokeAccess(
    revokeAccessOptions: {
      accountAccessGrants: {
        accountId: YOUR_ACCOUNT_ID
        roleId: "YOUR_ROLE_ID"
      }
      groupId: "YOUR_GROUP_ID"
    }
  ) {
    roles {
      accountId
      displayName
    }
  }
}

Respuesta para el éxito:

{
  "data": {
    "authorizationManagementRevokeAccess": {
      "roles": [
         {
          "displayName": "ROLE_NAME_1",
          "id": "ROLE_ID_1"
        },
        {
          "displayName": "ROLE_NAME_2",
          "id": "ROLE_ID_2"
        },
        {
          "displayName": "ROLE_NAME_3",
          "id": "ROLE_ID_3"
        }
      ]
    }
  }
}