Note :

Tirer parti des API REST des domaines d'identité et de gestion des accès OCI à l'aide de la clé de signature d'API

Présentation

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 recommandée pour sécuriser les demandes d'API. Toutefois, pour certains cas d'utilisation, en particulier lorsque la simplicité et la transparence sont primordiales, la clé de signature d'API offre une alternative viable.

Ce tutoriel explique comment appeler les API de domaine d'identité IAM OCI à l'aide de clés de signature d'API, fournissant 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 offre un moyen simple d'authentifier les demandes d'API. Ils sont faciles à générer et à utiliser, ce qui les rend idéaux 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 des scénarios tels que :

Public cible

Professionnels, développeurs et administrateurs du service IAM pour OCI.

Objectif

Tirez parti de l'API REST des domaines d'identité IAM OCI à l'aide de la clé de signature d'API. Pour le démontrer efficacement, l'extrait de code Python peut être utilisé pour développer un script. Ce script explique comment interagir avec les API de domaine d'identité IAM OCI à l'aide des 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, démontrant 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 flux de travail ou des scripts automatisés.

Préalables

Tâche 1 : Importer les ensembles Python et la configuration initiale

La partie initiale du script configure les importations et les configurations nécessaires pour interagir avec les API de domaine d'identité IAM OCI à 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

L'extrait de code définit une classe, APISignedRequest, pour gérer les interactions avec les API de domaine d'identité IAM OCI à 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 nouveau groupe dans le domaine d'identité IAM OCI.

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 nouvel utilisateur dans le domaine d'identité IAM OCI.

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 : Méthode d'affectation d'utilisateur au 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é IAM OCI.

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'ensemble 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 tout 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 Cloud Shell pour OCI dans le coin supérieur droit et chargez le script Python OCIAPISignedRequest.py.

Note : OCIAPISignedRequest.py est le script Python développé à l'aide des extraits de code des tâches 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é IAM d'OCI 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 pourrez effectuer une intégration sécurisée et efficace aux API de domaine d'identité IAM OCI, en tirant parti de la puissance des clés d'API pour l'authentification.

Que vous automatisiez des tâches administratives, que vous créiez des outils internes ou que vous fassiez du prototypage d'application, les clés d'API offrent une méthode flexible et pratique pour interagir avec les services OCI.

Remerciements

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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