Remarques :

Utiliser les API REST des domaines d'identité OCI Identity and Access Management à l'aide de la clé de signature d'API

Introduction

Lors de l'intégration aux API de domaines d'identité Oracle Cloud Infrastructure Identity and Access Management (OCI IAM), OAuth 2.0 est la méthode la plus couramment recommandée pour sécuriser les demandes d'API. Cependant, pour certains cas d'utilisation, en particulier lorsque la simplicité et la directs sont primordiales, la clé de signature d'API offre une alternative viable.

Ce tutoriel explique comment appeler des API de domaine d'identité OCI IAM à l'aide de clés de signature d'API, offrant ainsi une option plus simple et accessible aux développeurs et aux administrateurs.

Pourquoi utiliser la clé de signature d'API ?

La clé de signature d'API permet d'authentifier facilement les demandes d'API. Elles sont faciles à générer et à utiliser, ce qui les rend idéales pour les applications qui nécessitent un accès simple et programmatique sans la complexité du processus d'échange de jetons OAuth. Les clés d'API sont particulièrement utiles dans les scénarios suivants :

Public visé

Professionnels, développeurs et administrateurs d'OCI IAM.

Objectif

Tirez parti de l'API REST des domaines d'identité OCI IAM à l'aide de la clé de signature d'API. Pour le démontrer efficacement, le fragment de code Python peut être utilisé pour développer un script. Ce script explique comment interagir avec les API de domaine d'identité OCI IAM à l'aide de clés de signature d'API pour l'authentification. Il couvre également les opérations de base de création d'un groupe, de création d'un utilisateur et d'affectation de l'utilisateur au groupe, ce qui montre comment effectuer ces actions par programmation avec des demandes d'API sécurisées. L'utilisation de clés d'API simplifie le processus, ce qui facilite l'intégration de ces opérations dans des workflows ou des scripts automatisés.

Prérequis

Tâche 1 : import de packages Python et configuration initiale

La partie initiale du script configure les imports et configurations nécessaires pour interagir avec les API de domaine d'identité OCI IAM à l'aide de clés d'API.

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

Tâche 2 : définir et initialiser une classe

Le fragment de code définit une classe, APISignedRequest, pour gérer les interactions avec les API de domaine d'identité OCI IAM à l'aide de clés d'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'

Tâche 3 : créer une méthode de groupe

La méthode creategroup de la classe APISignedRequest est conçue pour créer un groupe dans le domaine d'identité 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

Tâche 4 : Créer une méthode utilisateur

La méthode createuser de la classe APISignedRequest est conçue pour créer un utilisateur dans le domaine d'identité 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

Tâche 5 : Affecter un utilisateur à une méthode de groupe

La méthode assignuser de la classe APISignedRequest gère le processus d'affectation d'un utilisateur à un groupe dans le domaine d'identité 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")

Tâche 6 : exécuter le flux

Créer une instance et une méthode d'appel : créez une instance de APISignedRequest et appelez assignuser pour exécuter l'intégralité du flux.

obj = APISignedRequest()
obj.assignuser()

Tâche 7 : utiliser le script dans OCI Cloud Shell

Une fois le script prêt, il peut être facilement exécuté sur la machine locale (avec Python installé) ou sur n'importe quel environnement de développement intégré (IDE) qui prend en charge le développement Python. Nous utilisons OCI Cloud Shell pour exécuter le script et obtenir le rapport souhaité.

  1. Connectez-vous à la console OCI, ouvrez OCI Cloud Shell dans l'angle supérieur droit et téléchargez le script Python OCIAPISignedRequest.py.

Remarque : OCIAPISignedRequest.py est le script Python développé à l'aide des fragments de code de tâche ci-dessus.

Image 1

Image 2

Image 3

  1. Exécutez la commande python OCIAPISignedRequest.py.

Conclusion

L'utilisation de clés d'API pour appeler les API de domaine d'identité OCI IAM offre une alternative simple à OAuth, idéale pour certains cas d'utilisation où la simplicité et la facilité d'utilisation sont essentielles. Après ce tutoriel, vous pouvez intégrer les API de domaine d'identité OCI IAM de manière sécurisée et efficace, en tirant parti de la puissance des clés d'API pour l'authentification.

Que vous automatisiez des tâches d'administration, construisiez des outils internes ou prototypiez des applications, les clés d'API offrent une méthode flexible et pratique pour interagir avec les services OCI.

Remerciements

Ressources de formation supplémentaires

Parcourez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, rendez-vous sur education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.