Object Storage Service:OSS Python SDK V1

Prepare o ambiente

yum install python-devel

yum install python-devel

yum install python-devel

apt-get install python-dev

apt-get install python-dev

Instale o SDK

Instale o SDK usando um dos métodos a seguir. Utilize a versão mais recente para garantir a compatibilidade com os exemplos de código.

Configure as credenciais de acesso

Agora, configure as credenciais de acesso com o par de AccessKey de um usuário RAM.

1. No console do RAM, crie um usuário RAM com um Permanent AccessKey Pair. Salve o par de AccessKey e conceda a permissão AliyunOSSFullAccess ao usuário.

2. Use o par de AccessKey do usuário RAM para configurar as variáveis de ambiente.

   Linux

   1. Execute os seguintes comandos na interface de linha de comando para adicionar as configurações de variáveis de ambiente ao arquivo ~/.bashrc .

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

   2. Execute o seguinte comando para aplicar as alterações.

      source ~/.bashrc

   3. Agora, verifique se as variáveis de ambiente estão configuradas com os seguintes comandos.

      echo $OSS_ACCESS_KEY_ID
      echo $OSS_ACCESS_KEY_SECRET

   macOS

   1. Execute o seguinte comando no terminal e visualize o tipo de shell padrão.

      echo $SHELL

   2. Execute as seguintes operações com base no tipo de shell padrão.

      Zsh

      1. Execute os seguintes comandos para adicionar as configurações de variáveis de ambiente ao arquivo ~/.zshrc.

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

      2. Execute o seguinte comando para aplicar as alterações.

         source ~/.zshrc

      3. Agora, verifique se as variáveis de ambiente estão configuradas com os seguintes comandos.

         echo $OSS_ACCESS_KEY_ID
         echo $OSS_ACCESS_KEY_SECRET

      Bash

      1. Execute os seguintes comandos para adicionar as configurações de variáveis de ambiente ao arquivo ~/.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. Execute o seguinte comando para aplicar as alterações.

         source ~/.bash_profile

      3. Agora, verifique se as variáveis de ambiente estão configuradas com os seguintes comandos.

         echo $OSS_ACCESS_KEY_ID
         echo $OSS_ACCESS_KEY_SECRET

   Windows

   CMD

   1. Execute os seguintes comandos no CMD.

      setx OSS_ACCESS_KEY_ID "YOUR_ACCESS_KEY_ID"
      setx OSS_ACCESS_KEY_SECRET "YOUR_ACCESS_KEY_SECRET"

   2. Agora, verifique se as variáveis de ambiente estão configuradas com os seguintes comandos.

      echo %OSS_ACCESS_KEY_ID%
      echo %OSS_ACCESS_KEY_SECRET%

   PowerShell

   1. Execute os seguintes comandos no 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)

   2. Agora, verifique se as variáveis de ambiente estão configuradas com os seguintes comandos.

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

Inicialize o cliente

A maioria das operações com o OSS Python SDK V1 utiliza as classes oss2.Service e oss2.Bucket.

• A classe oss2.Service lista buckets. Ela não oferece suporte a acesso por meio de nomes de domínio personalizados.

• A classe oss2.Bucket realiza o upload, o download e a exclusão de arquivos, além de configurar diversas definições do bucket.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Sample code for initializing a client with OSS Python SDK V1

import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

def main():

    # Load access credentials from environment variables. You must set the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    # Set the OSS service region.
    region = "<region-id>"
    # Set the endpoint.
    endpoint = "<endpoint>"
    # Set the bucket name.
    bucket_name = "example-bucket"

    # Initialize an OSS Bucket instance.
    bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
    
    # List files in the bucket.
    print("=== List files in the bucket ===")
    try:
        # Use the list_objects method to list files.
        result = bucket.list_objects()
        
        # Iterate through the file list and print only the file names.
        for obj in result.object_list:
            print(obj.key)
        
        # Print statistics.
        print(f"\nTotal files listed: {len(result.object_list)}")
        if result.is_truncated:
            print("Note: The result is truncated. More files are available.")
            
    except oss2.exceptions.OssError as e:
        print(f"OSS error: {e}")
        raise
    except Exception as e:
        print(f"An error occurred: {e}")
        raise

if __name__ == "__main__":
    # Entry point of the program.
    try:
        main()
    except Exception as e:
        print(f"An error occurred during execution: {e}")
        raise

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Sample code for initializing a Service instance with OSS Python SDK V1

import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

def main():

    # Load access credentials from environment variables. You must set the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    # Set the OSS service region.
    region = "<region-id>"
    # Set the endpoint.
    endpoint = "<endpoint>"

    # Initialize an OSS Service instance.
    service = oss2.Service(auth, endpoint, region=region)
    
    # List all buckets.
    print("=== List all buckets ===")
    try:
        # Use BucketIterator to list buckets.
        buckets = [b.name for b in oss2.BucketIterator(service)]
        
        # Iterate through the bucket list and print only the bucket names.
        for bucket in buckets:
            print(bucket)
        
        # Print statistics.
        print(f"\nTotal buckets listed: {len(buckets)}")
            
    except oss2.exceptions.OssError as e:
        print(f"OSS error: {e}")
        raise
    except Exception as e:
        print(f"An error occurred: {e}")
        raise

if __name__ == "__main__":
    # Entry point of the program.
    try:
        main()
    except Exception as e:
        print(f"An error occurred during execution: {e}")
        raise

Use um nome de domínio interno

Para acessar o OSS por meio de uma rede interna, use o nome de domínio interno como endpoint.

Substitua o espaço reservado <region-id> no código pelos valores reais de region , como ap-southeast-1 .

endpoint = "oss-<region-id>-internal.aliyuncs.com"

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

Use um nome de domínio personalizado

Para usar um nome de domínio personalizado, defina o endpoint para o seu domínio e ative is_cname=True.

Mapeie seu nome de domínio personalizado para o seu bucket antes de usá-lo. Access OSS by Using Custom Domain Names .

# Set the custom domain name.
endpoint = "http://example.com"

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, is_cname=True, region=region)

Controle de tempo limite

Defina o parâmetro connect_timeout (em segundos) ao inicializar o cliente. Padrão: 60 segundos.

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, connect_timeout=30, region=region)

Tamanho do pool de conexões

Ajuste o tamanho do pool de conexões com o parâmetro pool_size do objeto session.

# Set the connection pool size. The default value is 10.
session = oss2.Session(pool_size=20)

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, session=session, region=region)

Versão do TLS

Para especificar uma versão do TLS, crie uma sessão usando um SSLAdapter personalizado.

O Python SDK 2.18.1 e versões posteriores permitem especificar a versão do TLS.

import ssl
from requests.adapters import HTTPAdapter

# Define a custom adapter to specify the TLS version.
class SSLAdapter(HTTPAdapter):
    def init_poolmanager(self, *args, **http_client_config):
        # Specify TLS 1.2.
        http_client_config["ssl_version"] = ssl.PROTOCOL_TLSv1_2
        return super(SSLAdapter, self).init_poolmanager(*args, **http_client_config)
        
# Create a session by using SSLAdapter.
session = oss2.Session(adapter=SSLAdapter())

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, session=session, region=region)

Desative a verificação CRC

Para desativar a verificação de integridade de dados CRC, defina o parâmetro enable_crc=False.

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, enable_crc=False, region=region)

Versão da assinatura

O exemplo a seguir inicializa um cliente com a assinatura V1. Para a inicialização com a assinatura V4, consulte Initialize a Client.

Antes de executar o código de exemplo, substitua os espaços reservados como <endpoint> pelos valores reais de region and endpoint , como https://oss-ap-southeast-1.aliyuncs.com .

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# OSS Python SDK V1 client initialization sample code
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

def main():

    # Load access credentials from environment variables. You must set the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.
    auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())

    # Set the endpoint.
    endpoint = "<endpoint>"
    # Set the bucket name.
    bucket_name = "example-bucket"

    # Initialize an OSS bucket instance.
    bucket = oss2.Bucket(auth, endpoint, bucket_name)
    
    # List files in the bucket.
    print("=== List files in the bucket ===")
    try:
        # List files by using the list_objects() method.
        result = bucket.list_objects()
        
        # Iterate through the object list and print each object's key.
        for obj in result.object_list:
            print(obj.key)
        
        # Print statistics.
        print(f"\nTotal files listed: {len(result.object_list)}")
        if result.is_truncated:
            print("Note: The result is truncated. More files are available.")
            
    except oss2.exceptions.OssError as e:
        print(f"OSS error: {e}")
        raise
    except Exception as e:
        print(f"An error occurred: {e}")
        raise

if __name__ == "__main__":
    # Program entry point.
    try:
        main()
    except Exception as e:
        print(f"An error occurred while running the program: {e}")
        raise

Nome de aplicativo personalizado

Defina o parâmetro app_name para adicionar um identificador personalizado ao cabeçalho User-Agent. Padrão: string vazia.

O nome do aplicativo é transmitido como um valor de cabeçalho HTTP e deve estar em conformidade com os padrões HTTP.

# Initialize an OSS bucket instance.
bucket = oss2.Bucket(auth, endpoint, bucket_name, app_name="client_test", region=region)

AK de usuário RAM

Adequado para ambientes seguros e estáveis que exigem acesso de longo prazo ao OSS sem rotação frequente de credenciais. Inicialize o provedor de credenciais com a AccessKey (AK) de um usuário RAM. Esse método requer manutenção manual da AK, o que introduz riscos de segurança.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# OSS Python SDK V1: Sample code for client initialization

import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

def main():

    # Specify the AccessKey ID and AccessKey Secret of a RAM user.
    access_key_id = 'yourAccessKeyID'
    access_key_secret = 'yourAccessKeySecret'
    # Configure access credentials using the Access Key (AK) of the RAM user.
    auth = oss2.AuthV4(access_key_id, access_key_secret)
    # Set the OSS service region.
    region = "<region-id>"
    # Set the endpoint.
    endpoint = "<endpoint>"
    # Set the bucket name.
    bucket_name = "example-bucket-hz"

    # Initialize an OSS Bucket instance.
    bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
    
    # List objects in the bucket.
    print("=== List objects in the bucket ===")
    try:
        # Use the list_objects method to list objects.
        result = bucket.list_objects()
        
        # Iterate through the object list and print only the object keys.
        for obj in result.object_list:
            print(obj.key)
        
        # Print statistics.
        print(f"\nTotal objects listed: {len(result.object_list)}")
        if result.is_truncated:
            print("Note: The result is truncated. More objects are not listed.")
            
    except oss2.exceptions.OssError as e:
        print(f"OSS error: {e}")
        raise
    except Exception as e:
        print(f"An error occurred: {e}")
        raise

if __name__ == "__main__":
    # Entry point of the program.
    try:
        main()
    except Exception as e:
        print(f"An error occurred during execution: {e}")
        raise

Credenciais temporárias do STS

Adequado para aplicativos que exigem acesso temporário ao OSS. Inicialize o provedor de credenciais com credenciais temporárias (AccessKey ID, AccessKey Secret e token de segurança) do STS. Atualize o token STS manualmente antes que ele expire.

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

# Specify the temporary AccessKey ID and AccessKey Secret obtained from STS, not the AccessKey ID and AccessKey Secret of your Alibaba Cloud account.
# Note that the Access Key ID obtained from STS starts with "STS."
sts_access_key_id = 'STS.****************'
sts_access_key_secret = 'yourAccessKeySecret'
# Specify the security token obtained from STS.
security_token = 'yourSecurityToken'

# yourEndpoint specifies the endpoint for the region where the bucket is located.
endpoint = '<endpoint>'

# yourBucketName specifies the bucket name.
bucket_name = 'yourBucketName'

# Specify the region where the bucket is located.
region = '<region-id>'

# Initialize the StsAuth instance. Note that setting auth_version to "v4" enables OSS V4 signatures.
auth = oss2.StsAuth(sts_access_key_id,
                    sts_access_key_secret,
                    security_token,
                    auth_version="v4")

# Initialize the bucket using the StsAuth instance. Note that the region parameter is required when using V4 signatures;
# otherwise, an error occurs.
bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

# Use the bucket object for subsequent operations...

ARN de função RAM

Adequado para acesso entre contas. Inicialize o provedor de credenciais com um ARN de função RAM. A ferramenta de credenciais atualiza automaticamente o token STS chamando o AssumeRole antes que ele expire. Defina o parâmetro policy para restringir ainda mais as permissões.

1. Adicione a dependência de credenciais.

   pip install alibabacloud_credentials

2. Agora, configure a Access Key (AK) e o ARN da função RAM como credenciais de acesso.

   Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

   # -*- 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 Access Key (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',
       # The ARN of the RAM role to assume. Example: acs:ram::123456789012****:role/adminrole. You can set the RoleArn using the ALIBABA_CLOUD_ROLE_ARN environment variable.
       role_arn='<RoleArn>',
       # The role session name. You can set the RoleSessionName using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
       role_session_name='<RoleSessionName>',
       # Optional. A more restrictive permission policy. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
       policy='<Policy>',
       # Optional. The validity period of the role session.
       role_session_expiration=3600
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates the use of V4 signatures.
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # yourEndpoint specifies the endpoint for the region where the bucket is located.
   endpoint = '<endpoint>'
   
   # yourBucketName specifies the bucket name.
   bucket_name = 'yourBucketName'
   
   # Specify the region where the bucket is located.
   region = '<region-id>'
   
   # Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
   # otherwise, an error occurs.
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations...

Função RAM de instância ECS

Adequado para aplicativos em instâncias ECS, instâncias ECI ou nós de trabalho do Container Service for Kubernetes (ACK). A função RAM de instância ECS permite a atualização automática do token STS nesses ambientes sem a necessidade de fornecer uma AK ou token STS. Para obter uma função, consulte Create a RAM role. Para anexá-la a uma instância, consulte Instance RAM role.

1. Adicione a dependência de credenciais.

   pip install alibabacloud_credentials

2. Agora, configure a função RAM da instância ECS como a credencial de acesso.

   Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

   # -*- 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',      # Credential type. Fixed value: ecs_ram_role.
       role_name='<RoleName>'    # The name of the RAM role attached to the ECS instance. Optional. If not set, it is retrieved automatically. We strongly recommend setting this parameter to reduce requests.
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates the use of V4 signatures.
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # yourEndpoint specifies the endpoint for the region where the bucket is located.
   endpoint = '<endpoint>'
   
   # yourBucketName specifies the bucket name.
   bucket_name = 'yourBucketName'
   
   # Specify the region where the bucket is located.
   region = '<region-id>'
   
   # Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
   # otherwise, an error occurs.
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations...

ARN de função OIDC

Quando aplicativos não confiáveis são executados em nós de trabalho do ACK, use o RRSA para impedir que eles obtenham o token STS da função RAM da instância do nó. O cluster monta um arquivo de token OIDC de conta de serviço por pod e injeta a configuração nas variáveis de ambiente. A ferramenta de credenciais troca o token OIDC por um token STS via AssumeRoleWithOIDC, sem exigir uma AK ou token STS. Consulte Configure RAM permissions for a ServiceAccount to implement pod permission isolation by using RRSA.

1. Adicione a dependência de credenciais.

   pip install alibabacloud_credentials

2. Agora, configure a função OIDC como a credencial de acesso.

   Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

   # -*- 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(
       # Credential type. Fixed value: oidc_role_arn.
       type='oidc_role_arn',
       # The ARN of the RAM role. You can set the RoleArn using the ALIBABA_CLOUD_ROLE_ARN environment variable.
       role_arn=os.environ.get('<RoleArn>'),
       # The ARN of the OIDC provider. You can set the OidcProviderArn using the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
       oidc_provider_arn=os.environ.get('<OidcProviderArn>'),
       # The OIDC token file path. You can set the OidcTokenFilePath using the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
       oidc_token_file_path=os.environ.get('<OidcTokenFilePath>'),
       # The role session name. You can set the RoleSessionName using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
       role_session_name='<RoleSessionName>',
       # Optional. A more restrictive permission policy. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
       policy='<Policy>',
       # The validity period of the session.
       role_session_expiration=3600
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates the use of V4 signatures.
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # yourEndpoint specifies the endpoint for the region where the bucket is located.
   endpoint = '<endpoint>'
   
   # yourBucketName specifies the bucket name.
   bucket_name = 'yourBucketName'
   
   # Specify the region where the bucket is located.
   region = '<region-id>'
   
   # Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
   # otherwise, an error occurs.
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations...

Contexto do Function Compute

Adequado para funções em execução no FC. O FC assume uma função de serviço para obter um token STS (válido por 36 horas) e o passa por meio do parâmetro Credentials do contexto. Como o tempo máximo de execução da função é de 24 horas, o token não expira durante a execução, portanto, nenhuma atualização é necessária. Para conceder permissões ao FC para acessar o OSS, consulte Use a function role to grant Function Compute permissions to access other cloud services.

Inicialize o provedor de credenciais com as credenciais do contexto do FC.

Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

# -*- 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 the use of V4 signatures.
    auth = oss2.ProviderAuthV4(credentials_provider)

    # yourEndpoint specifies the endpoint for the region where the bucket is located.
    endpoint = '<endpoint>'

    # yourBucketName specifies the bucket name.
    bucket_name = 'yourBucketName'

    # Specify the region where the bucket is located.
    region = '<region-id>'

    # Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
    # otherwise, an error occurs.
    bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

    # Use the bucket object for subsequent operations...

    return 'success'

URI de credenciais

Adequado para aplicativos que obtêm credenciais de um sistema externo. A ferramenta de credenciais recupera um token STS do URI fornecido e lida com a atualização automática.

1. Para garantir que a ferramenta de credenciais possa analisar e usar corretamente o token STS, a resposta do URI deve seguir o seguinte protocolo:

   • Código de status da resposta: 200

   • Estrutura do corpo da resposta:

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

2. Adicione a dependência de credenciais.

   pip install alibabacloud_credentials

3. Agora, configure o URI de credenciais como a credencial de acesso.

   Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

   # -*- 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',
       # The URI for the credentials, in the format http://local_or_remote_uri/. You can set the CredentialsUri using the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
       credentials_uri='<CredentialsUri>',
   )
   
   cred = Client(config)
   
   credentials_provider = CredentialProviderWrapper(cred)
   
   # Note that ProviderAuthV4 indicates the use of V4 signatures.
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # yourEndpoint specifies the endpoint for the region where the bucket is located.
   endpoint = '<endpoint>'
   
   # yourBucketName specifies the bucket name.
   bucket_name = 'yourBucketName'
   
   # Specify the region where the bucket is located.
   region = '<region-id>'
   
   # Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
   # otherwise, an error occurs.
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations...

AK com rotação automática

Adequado para ambientes onde a AK corre risco de comprometimento. Inicialize o provedor de credenciais com uma ClientKey do KMS, que faz a rotação automática da AK gerenciada do usuário RAM. O KMS também oferece suporte à rotação imediata se uma AK for comprometida. Para obter uma ClientKey, consulte Create an Application Access Point.

1. Adicione a dependência do cliente Secrets Manager.

   pip install aliyun-secret-manager-client

2. Crie um arquivo de configuração chamado secretsmanager.properties.

   # The type of access credential. Fixed value: client_key
   credentials_type=client_key
   
   # The decryption password for the ClientKey. You can read it from an environment variable or a file. Set only one.
   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>
   
   # The path to the private key file of the ClientKey.
   client_key_private_key_path=<your client key private key file path>
   
   # The region of the associated KMS.
   cache_client_region_id=[{"regionId":"<regionId>"}]

3. Use o arquivo de configuração para fornecer as informações da credencial.

   Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

   # -*- 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 the use of V4 signatures.
   auth = oss2.ProviderAuthV4(credentials_provider)
   
   # yourEndpoint specifies the endpoint for the region where the bucket is located.
   endpoint = '<endpoint>'
   
   # yourBucketName specifies the bucket name.
   bucket_name = 'yourBucketName'
   
   # Specify the region where the bucket is located.
   region = '<region-id>'
   
   # Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
   # otherwise, an error occurs.
   bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)
   
   # Use the bucket object for subsequent operations...

Provedor de credenciais personalizado

Caso nenhum dos métodos de configuração de credenciais acima atenda aos seus requisitos, defina um provedor de credenciais personalizado implementando a interface CredentialProvider. Se a sua implementação usar um token STS, também será necessário lidar com a atualização da credencial.

Antes de executar o código de exemplo, substitua os espaços reservados como <region-id> pelos valores reais de region and endpoint . Por exemplo, substitua <region-id> por ap-southeast-1 .

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

class CredentialProviderWrapper(CredentialsProvider):
    def get_credentials(self):
        # TODO
        # Implement your custom method for obtaining access credentials.

        # Return long-term credentials: access_key_id, access_key_secret
        return Credentials('<access_key_id>', '<access_key_secrect>')

        # Return temporary credentials: access_key_id, access_key_secret, token
        # For temporary credentials, you need to refresh them based on their expiration time.
        # return Credentials('<access_key_id>', '<access_key_secrect>', '<token>');

credentials_provider = CredentialProviderWrapper()

# Note that ProviderAuthV4 indicates the use of V4 signatures.
auth = oss2.ProviderAuthV4(credentials_provider)

# yourEndpoint specifies the endpoint for the region where the bucket is located.
endpoint = '<endpoint>'

# yourBucketName specifies the bucket name.
bucket_name = 'yourBucketName'

# Specify the region where the bucket is located.
region = '<region-id>'

# Initialize the bucket by using the Auth instance. Note that the region parameter is required when using V4 signatures;
# otherwise, an error occurs.
bucket = oss2.Bucket(auth, endpoint, bucket_name, region=region)

# Use the bucket object for subsequent operations...

Erro: No module named _crcfunext?

Os uploads e downloads que usam o OSS Python SDK V1 são mais lentos do que com outras ferramentas, como o ossutil ou outros SDKs.

• Causa:

  A biblioteca _crcfunext.so não é gerada durante a compilação do crcmod porque o sistema não possui o arquivo Python.h necessário. Saiba mais sobre o crcmod na introdução do crcmod.

• Solução:

  Agora, verifique se o modo de extensão C para o crcmod está instalado corretamente.

  1. Execute o seguinte comando para entrar no ambiente Python.

     python

  2. Execute o seguinte comando para importar o módulo de extensão C _crcfunext do módulo crcmod.

     import crcmod._crcfunext

     O erro a seguir indica que a instalação do modo de extensão C para a biblioteca crcmod falhou.

     Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
     ImportError: No module named _crcfunext                                 

  3. Escolha uma solução com base no seu sistema operacional.

     Windows

     1. No Windows, baixe o arquivo crcmod-1.7.win32-py2.7.msi ou outra versão do arquivo .msi.

        Nota

        A versão de 32 bits do crcmod é compatível com sistemas Windows de 32 e 64 bits.

     2. Instale o arquivo .msi e, durante o processo de instalação, especifique o caminho de instalação do crcmod para a pasta Lib\site-packages no diretório de instalação local do Python. Por exemplo, D:\python\Lib\site-packages\.

     3. Após a conclusão da instalação, execute as etapas de verificação do crcmod novamente.

     Linux

     Se esse problema ocorrer em um sistema Linux, execute as seguintes etapas:

     1. Execute o seguinte comando para desinstalar o crcmod.

        pip uninstall crcmod

     2. Instale o python-devel. Consulte Prepare the environment.

     3. Execute o seguinte comando para reinstalar o crcmod.

        pip install crcmod

        Se a instalação falhar novamente, desinstale o crcmod e execute o seguinte comando e visualize informações detalhadas do erro.

        pip install crcmod -v

Erro: No module named 'Crypto'?

• Causa:

  O módulo Crypto não existe no sistema, ou existe o módulo crypto (com a letra inicial minúscula).

• Solução:

  Agora, verifique se existe o módulo Crypto no caminho de instalação local do Python, por exemplo, D:\python3.9\Lib\site-packages.

  • Se o módulo Crypto não existir, execute o seguinte comando.

    python -m pip install --upgrade setuptools

  • Se existir um módulo chamado crypto (com c minúsculo), renomeie-o para Crypto e reinicie seu programa.

Erro: "não é um comando interno ou externo"?

No Windows, se você receber a mensagem 'não é reconhecido como um comando interno ou externo', adicione os caminhos de instalação do Python e do pip (geralmente a pasta Scripts no diretório do Python) à variável de ambiente Path. Reinicie o computador para que as alterações entrem em vigor.

Falha na instalação do OSS Python SDK V1

Se a instalação falhar, desinstale e tente novamente.

pip uninstall oss2            

Atualize o OSS Python SDK V1

Execute o seguinte comando para atualizar o SDK.

 pip install --upgrade oss2

Solucione erros AccessDenied

Um erro AccessDenied indica permissões insuficientes. Solucione o problema da seguinte forma:

1. Certifique-se de usar o AccessKey ID e o AccessKey Secret corretos.

2. Agora, verifique se o usuário RAM tem as permissões necessárias para as operações de bucket ou objeto.

3. Agora, verifique a política do bucket: Uma mensagem de erro contendo "Access denied by bucket policy" indica que a solicitação foi bloqueada por uma política de bucket.

Melhore a velocidade de transferência para acesso intrarregião

Para transferências mais rápidas, acesse o OSS a partir de um product Alibaba Cloud (como o ECS) na mesma região do seu bucket, usando um endpoint interno.

Visualize AccessKeys e gerencie AccessKey Secrets

1. Para visualizar a AccessKey de um usuário RAM: acesse o console do RAM e selecione o usuário específico e visualize as informações de AccessKey.

2. O AccessKey Secret de um usuário RAM é exibido apenas no momento da criação. Se você o perder, crie uma nova AccessKey no console do RAM. Consulte Create an AccessKey.