:Configurer les identifiants d'accès à l'aide du SDK OSS pour Python 1.0

Utiliser la paire AccessKey d'un utilisateur RAM

Supposons que votre application nécessite un accès à long terme à OSS sans rotation fréquente des identifiants d'accès et qu'elle s'exécute dans un environnement sécurisé et stable, à l'abri des attaques externes. Dans ce cas, vous pouvez utiliser une paire AccessKey (un AccessKey ID et un AccessKey Secret) de votre compte Alibaba Cloud ou d'un utilisateur RAM pour initialiser un fournisseur d'identifiants. Notez que cette méthode exige une maintenance manuelle de la paire AccessKey, ce qui pose des risques de sécurité et augmente la complexité de la maintenance.

Variables d'environnement

1. Configurez les variables d'environnement pour la paire AccessKey de l'utilisateur RAM.

   Linux

   1. Exécutez les commandes suivantes dans l'interface de ligne de commande pour ajouter les paramètres de variable d'environnement au fichier ~/.bashrc .

      echo "export OSS_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.bashrc
      echo "export OSS_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.bashrc

      1. Exécutez la commande suivante pour appliquer les modifications.

         source ~/.bashrc

      2. Exécutez la commande suivante pour vérifier si les variables d'environnement sont effectives.

         echo $OSS_ACCESS_KEY_ID
         echo $OSS_ACCESS_KEY_SECRET

   macOS

   1. Exécutez la commande suivante dans le terminal pour vérifier le type de shell par défaut.

      echo $SHELL

      1. Effectuez les opérations en fonction du type de shell par défaut.

         Zsh

         1. Exécutez les commandes suivantes pour ajouter les paramètres de variable d'environnement au fichier ~/.zshrc.

            echo "export OSS_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.zshrc
            echo "export OSS_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.zshrc

         2. Exécutez la commande suivante pour appliquer les modifications.

            source ~/.zshrc

         3. Exécutez la commande suivante pour vérifier si les variables d'environnement sont effectives.

            echo $OSS_ACCESS_KEY_ID
            echo $OSS_ACCESS_KEY_SECRET

         Bash

         1. Exécutez les commandes suivantes pour ajouter les paramètres de variable d'environnement au fichier ~/.bash_profile.

            echo "export OSS_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.bash_profile
            echo "export OSS_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.bash_profile

         2. Exécutez la commande suivante pour appliquer les modifications.

            source ~/.bash_profile

         3. Exécutez la commande suivante pour vérifier si les variables d'environnement sont effectives.

            echo $OSS_ACCESS_KEY_ID
            echo $OSS_ACCESS_KEY_SECRET

   Windows

   CMD

   1. Exécutez les commandes suivantes dans CMD.

      setx OSS_ACCESS_KEY_ID "YOUR_ACCESS_KEY_ID"
      setx OSS_ACCESS_KEY_SECRET "YOUR_ACCESS_KEY_SECRET"

      1. Exécutez la commande suivante pour vérifier si les variables d'environnement sont effectives.

         echo %OSS_ACCESS_KEY_ID%
         echo %OSS_ACCESS_KEY_SECRET%

   PowerShell

   1. Exécutez les commandes suivantes dans PowerShell.

      [Environment]::SetEnvironmentVariable("OSS_ACCESS_KEY_ID", "YOUR_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
      [Environment]::SetEnvironmentVariable("OSS_ACCESS_KEY_SECRET", "YOUR_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)

      1. Exécutez la commande suivante pour vérifier si les variables d'environnement sont effectives.

         [Environment]::GetEnvironmentVariable("OSS_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
         [Environment]::GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)

2. Pour vous assurer que vos paramètres sont chargés, redémarrez ou actualisez vos environnements de compilation et d'exécution, tels que l'IDE, l'outil de ligne de commande, les applications de bureau et les services en arrière-plan.

3. Transmettez les identifiants à l'aide de variables d'environnement.

   # -*- coding: utf-8 -*-
   import oss2
   from oss2.credentials import EnvironmentVariableCredentialsProvider
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
   # Specify the name of the bucket. 
   bucket_name = 'yourBucketName'
   
   # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
   region = 'cn-hangzhou'
   
   # Use the AccessKey pair of the RAM user obtained from the environment variables to configure access credentials. Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
   auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
   
   # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations.

Identifiants statiques

L'exemple suivant montre comment intégrer directement les identifiants d'accès d'un utilisateur RAM dans le code :

# -*- coding: utf-8 -*-
import oss2

# Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'

# Specify the name of the bucket. 
bucket_name = 'yourBucketName'

# Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
region = 'cn-hangzhou'

# Enter the AccessKey ID and AccessKey secret of the RAM user.
access_key_id = 'yourAccessKeyID'
access_key_secret = 'yourAccessKeySecret'

# Use the AccessKey pair of the RAM user as access credentials. Note that AuthV4 indicates that the signature algorithm V4 is used. 
auth = oss2.AuthV4(access_key_id, access_key_secret)

# Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

# Use the bucket object for subsequent operations.

Utiliser les identifiants d'accès temporaires fournis par STS

Si votre application doit accéder temporairement à OSS, vous pouvez utiliser les identifiants d'accès temporaires fournis par STS, qui se composent d'une paire AccessKey et d'un jeton STS. Notez que cette méthode exige une maintenance manuelle du jeton STS, ce qui pose des risques de sécurité et augmente la complexité de la maintenance. Si vous souhaitez prolonger l'accès après l'expiration du jeton STS existant, vous devez actualiser manuellement le jeton STS.

Variables d'environnement

1. Configurez les variables d'environnement pour les identifiants d'accès temporaires.

   Mac OS X/Linux/Unix

   Avertissement

   • Notez que les identifiants d'accès temporaires (AccessKey ID, AccessKey Secret et jeton STS) fournis par STS sont utilisés à la place de l'AccessKey ID et de l'AccessKey Secret de l'utilisateur RAM.

   • L'AccessKey ID fourni par STS commence par STS. Exemple : STS..

   export OSS_ACCESS_KEY_ID=<STS_ACCESS_KEY_ID>
   export OSS_ACCESS_KEY_SECRET=<STS_ACCESS_KEY_SECRET>
   export OSS_SESSION_TOKEN=<STS_SECURITY_TOKEN>

   Windows

   Avertissement

   • Notez que les identifiants d'accès temporaires (AccessKey ID, AccessKey Secret et jeton STS) fournis par STS sont utilisés à la place de la paire AccessKey (AccessKey ID et AccessKey Secret) de l'utilisateur RAM.

   • L'AccessKey ID fourni par STS commence par STS. Exemple : STS..

   set OSS_ACCESS_KEY_ID=<STS_ACCESS_KEY_ID>
   set OSS_ACCESS_KEY_SECRET=<STS_ACCESS_KEY_SECRET>
   set OSS_SESSION_TOKEN=<STS_SECURITY_TOKEN>

2. Transmettez les informations d'identification à l'aide de variables d'environnement.

   # -*- coding: utf-8 -*-
   import oss2
   from oss2.credentials import EnvironmentVariableCredentialsProvider
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
   # Specify the name of the bucket. 
   bucket_name = 'yourBucketName'
   
   # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
   region = 'cn-hangzhou'
   
   # Use the AccessKey ID, AccessKey secret, and STS token as access credentials. ProviderAuthV4 indicates that the signature algorithm V4 is used. 
   auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
   
   # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations.

Identifiants statiques

L'exemple suivant montre comment intégrer directement les identifiants d'accès temporaires dans le code :

# -*- coding: utf-8 -*-
import oss2

# Specify the temporary AccessKey ID and AccessKey secret provided by STS, instead of the AccessKey ID and AccessKey secret of an Alibaba Cloud account. 
# Note that an AccessKey ID provided by STS starts with STS. 
sts_access_key_id = 'STS.****************'
sts_access_key_secret = 'yourAccessKeySecret'
# Specify the STS token obtained from STS. 
security_token = 'yourSecurityToken'

# Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'

# Specify the name of the bucket. 
bucket_name = 'yourBucketName'

# Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
region = 'cn-hangzhou'

# Initialize the StsAuth instance. Note that auth_version is set to v4, indicating that the signature algorithm V4 is used. 
auth = oss2.StsAuth(sts_access_key_id,
                    sts_access_key_secret,
                    security_token,
                    auth_version="v4")

# Use the StsAuth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

# Use the bucket object for subsequent operations.

Utiliser l'ARN d'un rôle RAM

Si vous devez autoriser votre application à accéder à OSS, par exemple dans un scénario d'accès intercomptes, vous pouvez utiliser le nom de ressource Alibaba Cloud (ARN) d'un rôle RAM pour initialiser un fournisseur d'identifiants. La logique sous-jacente de cette méthode consiste à utiliser un jeton STS obtenu auprès de STS pour configurer les identifiants d'accès. L'outil Credentials obtient un jeton STS basé sur l'ARN du rôle RAM et actualise ce jeton en appelant l'opération AssumeRole avant l'expiration de la session. Vous pouvez spécifier une policy pour limiter les autorisations accordées au rôle RAM.

1. Ajoutez la dépendance alibabacloud_credentials.

   pip install alibabacloud_credentials

2. Configurez la paire AccessKey et le RAMRoleARN comme identifiants d'accès.

   # -*- coding: utf-8 -*-
   import oss2
   from alibabacloud_credentials.client import Client
   from alibabacloud_credentials.models import Config
   from oss2 import CredentialsProvider
   from oss2.credentials import Credentials
   import os
   
   class CredentialProviderWrapper(CredentialsProvider):
       def __init__(self, client):
           self.client = client
   
       def get_credentials(self):
           credential = self.client.get_credential()
           access_key_id = credential.access_key_id
           access_key_secret = credential.access_key_secret
           security_token = credential.security_token
           return Credentials(access_key_id, access_key_secret, security_token)
   
   config = Config(
       # Obtain the AccessKey pair (AccessKey ID and AccessKey secret) of the RAM user from environment variables.
       access_key_id=os.getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
       access_key_secret=os.getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
       type='ram_role_arn',
       # Specify the ARN of the RAM role that you want your application to assume by specifying the ALIBABA_CLOUD_ROLE_ARN environment variable. Example: acs:ram::123456789012****:role/adminrole
       role_arn='<RoleArn>',
       # Specify the role session name by specifying the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
       role_session_name='<RoleSessionName>',
       # (Optional) Specify limited permissions. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
       policy='<Policy>',
       # (Optional) Specify the validity period of the role session.
       role_session_expiration=3600
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
   # Specify the name of the bucket. 
   bucket_name = 'yourBucketName'
   
   # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
   region = 'cn-hangzhou'
   
   # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations.
   

Utiliser le rôle RAM d'une instance ECS

Si votre application s'exécute sur une instance ECS, une instance de conteneur élastique ou un nœud de travail ACK, nous vous recommandons d'utiliser le rôle RAM de l'instance ECS pour initialiser un fournisseur d'identifiants. La logique sous-jacente de cette méthode consiste à utiliser un jeton STS obtenu auprès de STS pour configurer les identifiants d'accès. Vous pouvez associer un rôle RAM à une instance ECS, à une instance de conteneur élastique ou à un nœud de travail ACK afin d'actualiser automatiquement le jeton STS sur l'instance. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine les risques associés à la gestion manuelle de ces identifiants. Vous pouvez créer un rôle RAM en appelant l'opération CreateRole. L'ARN est inclus dans la réponse. Pour plus d'informations, consultez la rubrique CreateRole.

1. Ajoutez la dépendance alibabacloud_credentials.

   pip install alibabacloud_credentials

2. Utilisez le rôle RAM pour fournir les identifiants d'accès.

   # -*- coding: utf-8 -*-
   import oss2
   from alibabacloud_credentials.client import Client
   from alibabacloud_credentials.models import Config
   from oss2 import CredentialsProvider
   from oss2.credentials import Credentials
   
   class CredentialProviderWrapper(CredentialsProvider):
       def __init__(self, client):
           self.client = client
   
       def get_credentials(self):
           credential = self.client.get_credential()
           access_key_id = credential.access_key_id
           access_key_secret = credential.access_key_secret
           security_token = credential.security_token
           return Credentials(access_key_id, access_key_secret, security_token)
   
   config = Config(
       type='ecs_ram_role',      # Specify the credential type. Set the value to ecs_ram_role. 
       role_name='<RoleName>'    # Specify the name of the RAM role that is attached to the ECS instance. The RAM role name is optional. If you do not configure this parameter, the system automatically searches for a RAM role. We recommend that you configure this parameter to reduce the number of requests. 
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
   # Specify the name of the bucket. 
   bucket_name = 'yourBucketName'
   
   # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
   region = 'cn-hangzhou'
   
   # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations.
   

Utiliser le rôle d'un fournisseur d'identité OIDC

Une fois le rôle RAM configuré sur le nœud de travail ACK, les applications au sein des pods sur ce nœud peuvent récupérer le jeton STS pour le rôle associé via le serveur de métadonnées, de manière similaire à une application déployée sur une instance ECS. Toutefois, vous pourriez ne pas souhaiter que des applications non fiables, telles que celles soumises par des clients sans divulgation du code applicatif, accèdent au serveur de métadonnées pour obtenir le jeton STS du rôle RAM attaché au nœud de travail. Pour garantir la sécurité des ressources cloud, permettre aux applications non fiables d'obtenir en toute sécurité le jeton STS requis et minimiser les autorisations au niveau de l'application, vous pouvez utiliser la fonctionnalité Rôles RAM pour les comptes de service (RRSA). La logique sous-jacente de cette méthode consiste à utiliser un jeton STS obtenu auprès de STS pour configurer les identifiants d'accès. ACK crée et monte les fichiers de jeton OpenID Connect (OIDC) correspondants pour différents pods d'application, et transmet les informations de configuration pertinentes aux variables d'environnement. L'outil Credentials obtient les informations de configuration à partir des variables d'environnement et appelle l'opération AssumeRoleWithOIDC de STS pour obtenir le jeton STS pour les rôles associés. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine les risques associés à la gestion manuelle de ces identifiants. Pour plus d'informations, consultez la rubrique Utiliser RRSA pour le contrôle d'accès au niveau des pods.

Utiliser Credentials dans le contexte de Function Compute

Si la fonction de votre application est déployée et exécutée dans Function Compute, vous pouvez initialiser le fournisseur d'identifiants en utilisant Credentials dans le contexte de Function Compute. La logique sous-jacente de cette méthode consiste à utiliser un jeton STS obtenu auprès de STS pour configurer les identifiants d'accès. Function Compute obtient un jeton STS en assumant un rôle de service basé sur le rôle configuré pour la fonction. Ensuite, le jeton STS est transmis à votre application via Credentials dans le contexte. Le jeton STS est valide pendant 36 heures. Vous ne pouvez pas modifier sa durée de validité. Une fonction peut s'exécuter pendant un maximum de 24 heures. Vous n'avez pas besoin d'actualiser le jeton STS pendant l'exécution de la fonction, car il reste valide tout au long de celle-ci. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine les risques associés à la gestion manuelle de ces identifiants. Pour plus d'informations sur l'autorisation de Function Compute à accéder à OSS, consultez la rubrique Utiliser un rôle de fonction pour accéder à d'autres services cloud.

1. Initialisez le fournisseur d'identifiants en utilisant Credentials dans le contexte de Function Compute.

   # -*- coding: utf-8 -*-
   import oss2
   from oss2 import CredentialsProvider
   from oss2.credentials import Credentials
   
   def handler(event, context):
   
       class CredentialProviderWrapper(CredentialsProvider):
           def get_credentials(self):
               creds = context.credentials
               return Credentials(creds.access_key_id, creds.access_key_secret, creds.security_token)
   
       credentials_provider = CredentialProviderWrapper()
       # Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
       auth = oss2.ProviderAuthV4(credentials_provider)
   
       # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
       endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
       # Specify the name of the bucket. 
       bucket_name = 'yourBucketName'
   
       # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
       region = 'cn-hangzhou'
   
       # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
       bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
       # Use the bucket object for subsequent operations.
   
       return 'success'
   

Utiliser CredentialsURI

Si votre application doit obtenir des identifiants Alibaba Cloud à partir d'un système externe pour mettre en œuvre une gestion flexible des identifiants et un accès sans clé, vous pouvez utiliser CredentialsURI pour initialiser un fournisseur d'identifiants. La logique sous-jacente de cette méthode consiste à utiliser un jeton STS obtenu auprès de STS pour configurer les identifiants d'accès. L'outil Credentials obtient le jeton STS en utilisant l'URI spécifié pour initialiser le client. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine les risques associés à la gestion manuelle de ces identifiants.

1. Pour permettre à l'outil Credentials d'analyser et d'utiliser correctement un jeton STS, l'URI doit respecter les exigences suivantes :

   • Code d'état de la réponse : 200

   • Structure du corps de la réponse :

     {
         "Code": "Success",
         "AccessKeySecret": "AccessKeySecret",
         "AccessKeyId": "AccessKeyId",
         "Expiration": "2021-09-26T03:46:38Z",
         "SecurityToken": "SecurityToken"
     }

2. Ajoutez la dépendance alibabacloud_credentials.

   pip install alibabacloud_credentials

3. Configurez l'URI comme identifiant d'accès.

   # -*- coding: utf-8 -*-
   import oss2
   from alibabacloud_credentials.client import Client
   from alibabacloud_credentials.models import Config
   from oss2 import CredentialsProvider
   from oss2.credentials import Credentials
   
   class CredentialProviderWrapper(CredentialsProvider):
       def __init__(self, client):
           self.client = client
   
       def get_credentials(self):
           credential = self.client.get_credential()
           access_key_id = credential.access_key_id
           access_key_secret = credential.access_key_secret
           security_token = credential.security_token
           return Credentials(access_key_id, access_key_secret, security_token)
   
   config = Config(
       type='credentials_uri',
       # Specify the URI of the credential in the http://local_or_remote_uri/ format by specifying the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
       credentials_uri='<CredentialsUri>',
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
   # Specify the name of the bucket. 
   bucket_name = 'yourBucketName'
   
   # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
   region = 'cn-hangzhou'
   
   # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations.
   

Utiliser une paire AccessKey à rotation automatique

Si votre application nécessite un accès à long terme à OSS, vous devez effectuer manuellement la rotation de la paire AccessKey pour réduire les risques de fuite d'identifiants. Dans ce cas, vous pouvez utiliser une clé cliente pour initialiser le fournisseur d'identifiants. La logique sous-jacente de cette méthode consiste à utiliser une paire AccessKey pour accéder aux ressources OSS. Après avoir utilisé une clé cliente, Key Management Service (KMS) peut faire tourner automatiquement et régulièrement la paire AccessKey d'un utilisateur RAM géré et modifier dynamiquement la paire AccessKey statique de l'utilisateur RAM. Cela réduit le risque de fuite de la paire AccessKey. KMS prend également en charge la rotation immédiate pour désactiver rapidement une paire AccessKey compromise. Cela élimine le besoin de maintenir manuellement une paire AccessKey et réduit les risques de sécurité ainsi que la complexité de la maintenance. Pour plus d'informations sur l'obtention d'une clé cliente, consultez la rubrique Créer un point d'accès applicatif.

1. Ajoutez les dépendances d'identifiants.

   pip install aliyun-secret-manager-client

2. Créez un fichier de configuration nommé secretsmanager.properties.

   # Set the credential type to client_key.
   credentials_type=client_key
   
   # Specify the decryption password of the client key. You can read the decryption password from environment variables or a file.
   client_key_password_from_env_variable=<your client key private key password environment variable name>
   client_key_password_from_file_path=<your client key private key password file path>
   
   # Specify the path of the private key file of the client key.
   client_key_private_key_path=<your client key private key file path>
   
   # Specify the ID of the region in which you want to use KMS.
   cache_client_region_id=[{"regionId":"<regionId>"}]

3. Transmettez les identifiants à l'aide du fichier de configuration.

   # -*- coding: utf-8 -*-
   import json
   import oss2
   from oss2 import CredentialsProvider
   from oss2.credentials import Credentials
   from alibaba_cloud_secretsmanager_client.secret_manager_cache_client_builder import SecretManagerCacheClientBuilder
   
   class CredentialProviderWrapper(CredentialsProvider):
       def get_credentials(self):
           secret_cache_client = SecretManagerCacheClientBuilder.new_client()
           secret_info = secret_cache_client.get_secret_info("<secretName>")
           secret_value_json = json.loads(secret_info.secret_value)
           return Credentials(secret_value_json["AccessKeyId"], secret_value_json["AccessKeySecret"])
   
   credentials_provider = CredentialProviderWrapper()
   
   # Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
   endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
   
   # Specify the name of the bucket. 
   bucket_name = 'yourBucketName'
   
   # Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
   region = 'cn-hangzhou'
   
   # Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations.
   

Utiliser des identifiants d'accès personnalisés

Si aucune des méthodes précédentes ne répond à vos besoins, vous pouvez spécifier une méthode personnalisée pour obtenir des identifiants d'accès en appelant l'opération CredentialsProvider. Notez que si l'implémentation sous-jacente est basée sur un jeton STS, vous devez fournir une prise en charge de la mise à jour des identifiants.

# -*- coding: utf-8 -*-
import oss2
from oss2 import CredentialsProvider
from oss2.credentials import Credentials

class CredentialProviderWrapper(CredentialsProvider):
    def get_credentials(self):
        # TODO
        # Specify the method used to obtain the custom access credentials.

        # Return long-term access credentials (an AccessKey ID and an AccessKey secret).
        return Credentials('<access_key_id>', '<access_key_secrect>')

        # Return temporary access credentials (an AccessKey ID, an AccessKey secret, and an STS token.
        # Refresh the temporary access credentials based on the validity period. 
        # return Credentials('<access_key_id>', '<access_key_secrect>', '<token>');

credentials_provider = CredentialProviderWrapper()

# Note that ProviderAuthV4 indicates that the signature algorithm V4 is used. 
auth = oss2.ProviderAuthV4(credentials_provider)

# Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'

# Specify the name of the bucket. 
bucket_name = 'yourBucketName'

# Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. 
region = 'cn-hangzhou'

# Use the Auth instance to initialize the bucket. When you use the signature algorithm V4, you must specify the region parameter. Otherwise, an error is returned. 
bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

# Use the bucket object for subsequent operations.