Observação:

Aproveite as APIs REST de Domínios de Identidade do OCI Identity and Access Management usando a Chave de Assinatura de API

Introdução

Ao fazer a integração com APIs de Domínios de Identidade do OCI IAM (Oracle Cloud Infrastructure Identity and Access Management), o OAuth 2.0 é o método mais recomendado para proteger solicitações de API. No entanto, para certos casos de uso, especialmente onde a simplicidade e a diretividade são fundamentais, a chave de assinatura de API oferece uma alternativa viável.

Este tutorial explorará como você pode chamar APIs do Domínio de Identidades do OCI IAM usando chaves de assinatura de API, fornecendo uma opção mais direta e acessível para desenvolvedores e administradores.

Por que Usar a Chave de Assinatura de API?

A chave de assinatura da API fornece uma maneira direta de autenticar solicitações de API. Eles são fáceis de gerar e usar, tornando-os ideais para aplicativos que exigem acesso simples e programático sem a complexidade do processo de troca de token OAuth. As chaves de API são especialmente úteis em cenários como:

Público-alvo

Profissionais, desenvolvedores e administradores do OCI IAM.

Objetivo

Aproveite a API REST de Domínios de Identidade do OCI IAM usando a chave de assinatura da API. Para demonstrar isso de forma eficaz, o snippet do Python pode ser usado para desenvolver um script. Este script ilustra como interagir com APIs de Domínio de Identidades do OCI IAM usando chaves de Assinatura de API para autenticação. Ele também abrange as operações básicas de criação de um grupo, criação de um usuário e atribuição do usuário ao grupo, demonstrando como executar essas ações de forma programática com solicitações de API seguras. O uso de chaves de API simplifica o processo, facilitando a integração dessas operações em fluxos de trabalho ou scripts automatizados.

Pré-requisitos

Tarefa 1: Importar Pacotes Python e Configuração Inicial

A parte inicial do script configura as importações e configurações necessárias para interagir com APIs do Domínio de Identidades do OCI IAM usando chaves de API.

import requests
import json
from oci.config import from_file
from oci.signer import Signer

Tarefa 2: Definir e Inicializar uma Classe

O trecho de código define uma classe, APISignedRequest, para gerenciar interações com APIs do Domínio de Identidades do OCI IAM usando chaves de API.

class APISignedRequest():
    def __init__(self):
        global auth
        global identity_domain
        global config

        config = from_file()
        auth = Signer(
            tenancy=config['tenancy'],
            user=config['user'],
            fingerprint=config['fingerprint'],
            private_key_file_location=config['key_file']
        )
        identity_domain = 'https://idcs-############################.identity.oraclecloud.com'

Tarefa 3: Criar Método de Grupo

O método creategroup na classe APISignedRequest foi projetado para criar um novo grupo no Domínio de Identidades do OCI IAM.

def creategroup(self):
    extra = "/admin/v1/Groups"
    body = {
        "displayName": "Example Group",
        "externalId": "123456",
        "urn:ietf:params:scim:schemas:oracle:idcs:extension:group:Group": {
            "creationMechanism": "api",
            "description": "Example Description"
        },
        "schemas": [
            "urn:ietf:params:scim:schemas:core:2.0:Group",
            "urn:ietf:params:scim:schemas:oracle:idcs:extension:group:Group",
            "urn:ietf:params:scim:schemas:extension:custom:2.0:Group"
        ]
    }

    response = requests.post(identity_domain + extra, auth=auth, json=body)
    jsonresp = json.loads(response.content)
    grpid = jsonresp.get("id")
    print("Group has been created")
    return grpid

Tarefa 4: Criar Método do Usuário

O método createuser na classe APISignedRequest foi projetado para criar um novo usuário no Domínio de Identidades do OCI IAM.

def createuser(self):
extra = "/admin/v1/Users"
body = {
  "schemas": [
    "urn:ietf:params:scim:schemas:core:2.0:User"
  ],
  "name": {
    "givenName": "Test",
    "familyName": "User"
  },
  "userName": "testuser@example.com",
  "emails": [
    {
      "value": "testuser@example.com",
      "type": "work",
      "primary": True
    },
    {
      "value": "testuser@example.com",
      "primary": False,
      "type": "recovery"
    }
  ]
}

response = requests.post(identity_domain + extra, auth=auth, json=body)
jsonresp = json.loads(response.content)
userid = jsonresp.get("id")
print("User has been created")
return userid

Tarefa 5: Atribuir Usuário ao Método de Grupo

O método assignuser na classe APISignedRequest trata o processo de designação de um usuário a um grupo no Domínio de Identidades do OCI IAM.

def assignuser(self):
    extra = "/admin/v1/Groups/"
    obj = APISignedRequest()
    grpid = obj.creategroup()
    gid = str(grpid)
    userid = obj.createuser()

    body = {
      "schemas": [
        "urn:ietf:params:scim:api:messages:2.0:PatchOp"
      ],
      "Operations": [
        {
          "op": "add",
          "path": "members",
          "value": [
            {
              "value": userid,
              "type": "User"
            }
          ]
        }
      ]
    }

    response = requests.patch(identity_domain + extra + gid, auth=auth, json=body)
    print("User has been assigned to the group")

Tarefa 6: Executar o Fluxo

Criar Instância e Método de Chamada: Crie uma instância de APISignedRequest e chame assignuser para executar todo o fluxo.

obj = APISignedRequest()
obj.assignuser()

Tarefa 7: Usar o Script no OCI Cloud Shell

Quando o script estiver pronto, ele poderá ser facilmente executado na máquina local (com Python instalado) ou em qualquer ambiente de desenvolvimento integrado (IDE) que suporte o desenvolvimento Python. Estamos usando o OCI Cloud Shell para executar o script e obter o relatório desejado.

  1. Faça log-in na Console do OCI, abra o OCI Cloud Shell no canto superior direito e faça upload do script Python OCIAPISignedRequest.py.

Observação: OCIAPISignedRequest.py é o script Python desenvolvido usando os trechos de código de tarefas acima.

Imagem 1

Imagem 2

Imagem 3

  1. Execute o comando python OCIAPISignedRequest.py.

Conclusão

O uso de chaves de API para chamar APIs de Domínio de Identidades do OCI IAM fornece uma alternativa direta ao OAuth, ideal para determinados casos de uso em que a simplicidade e a facilidade de uso são cruciais. Após este tutorial, você poderá se integrar de forma segura e eficiente às APIs do Domínio de Identidades do OCI IAM, aproveitando o poder das chaves de API para autenticação.

Quer você esteja automatizando tarefas administrativas, criando ferramentas internas ou projetando aplicativos, as chaves de API oferecem um método flexível e conveniente para interagir com os serviços da OCI.

Confirmação

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.