Object Storage Service:Autoriser l'accès (SDK C)

Notes

• Cette rubrique utilise le point de terminaison public de la région Chine (Hangzhou). Si vous souhaitez accéder à OSS depuis d'autres services Alibaba Cloud situés dans la même région, utilisez un point de terminaison interne. Pour plus d'informations sur les régions et les points de terminaison OSS, reportez-vous à Régions et points de terminaison.

• Cette rubrique illustre la création d'une instance OSSClient avec un point de terminaison OSS. Pour d'autres configurations, telles que l'utilisation d'un domaine personnalisé ou l'authentification via des identifiants issus de Security Token Service (STS), consultez Initialisation (SDK C).

Utiliser STS pour autoriser un accès temporaire

OSS prend en charge l'autorisation d'accès temporaire via Alibaba Cloud Security Token Service (STS). STS est un service web qui fournit des jetons d'accès temporaires aux utilisateurs du cloud computing. Avec STS, vous pouvez émettre des identifiants d'accès dotés d'une durée de validité et de permissions personnalisées à des applications tierces ou à des sous-utilisateurs (utilisateurs dont vous gérez les identités). Pour plus d'informations sur STS, consultez Présentation de STS.

STS offre les avantages suivants :

• Vous n'avez pas besoin d'exposer votre paire AccessKey à long terme à des applications tierces. Vous pouvez plutôt générer un jeton d'accès et le fournir à l'application. Vous avez la possibilité de personnaliser les permissions d'accès ainsi que la durée de validité de ce jeton.

• Aucune gestion de la révocation des permissions n'est nécessaire. Le jeton d'accès devient automatiquement invalide à son expiration.

Pour accéder à OSS en utilisant des identifiants d'accès temporaires provenant de STS, procédez comme suit :

1. Obtenir des identifiants d'accès temporaires

   Les identifiants d'accès temporaires comprennent une paire AccessKey temporaire (un ID AccessKey et un secret AccessKey) ainsi qu'un jeton de sécurité (SecurityToken). La durée de validité des identifiants d'accès temporaires est exprimée en secondes. La valeur minimale est de 900. La valeur maximale correspond à la durée maximale de session définie pour le rôle RAM actuel. Pour plus d'informations, consultez Définir la durée maximale de session pour un rôle RAM.

   Vous pouvez obtenir des identifiants d'accès temporaires de l'une des manières suivantes.

   • Méthode 1

     Appelez l'opération AssumeRole pour obtenir des identifiants d'accès temporaires.

   • Méthode 2

     Utilisez les SDK STS pour obtenir des identifiants d'accès temporaires. Pour plus d'informations, consultez SDK STS.

2. Utilisez les identifiants STS pour créer une requête signée.

   • Télécharger un fichier

     #include "oss_api.h"
     #include "aos_http_io.h"
     /* Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
     const char *endpoint = "yourEndpoint";
     /* Before you run this sample code, make sure that you have set the YOUR_ACCESS_KEY_ID and YOUR_ACCESS_KEY_SECRET environment variables based on the temporary AccessKey pair obtained from STS. */  
     const char *access_key_id = getenv("OSS_ACCESS_KEY_ID");
     const char *access_key_secret = getenv("OSS_ACCESS_KEY_SECRET");
     /* The security token (SecurityToken) obtained from STS. */
     const char *sts_token = "yourStsToken";
     /* Specify the bucket name. For example, examplebucket. */
     const char *bucket_name = "examplebucket";
     /* Specify the full path of the object. The full path cannot contain the bucket name. For example, exampledir/exampleobject.txt. */
     const char *object_name = "exampledir/exampleobject.txt";
     const char *object_content = "More than just cloud.";
     
     void init_options(oss_request_options_t *options)
     {
         options->config = oss_config_create(options->pool);
         /* Initialize the aos_string_t type with a char* string. */
         aos_str_set(&options->config->endpoint, endpoint);
         aos_str_set(&options->config->access_key_id, access_key_id);
         aos_str_set(&options->config->access_key_secret, access_key_secret);
         aos_str_set(&options->config->sts_token, sts_token);
         /* Specify whether to use a CNAME to access OSS. A value of 0 indicates that a CNAME is not used. */
         options->config->is_cname = 0;
         /* Set network parameters, such as the timeout period. */
         options->ctl = aos_http_controller_create(options->pool, 0);
     }
     
     int main(int argc, char *argv[])
     {
         /* Call the aos_http_io_initialize method at the program entry to initialize global resources, such as the network and memory. */
         if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
             exit(1);
         }
     
         /* The memory pool (pool) for memory management, which is equivalent to apr_pool_t. Its implementation code is in the APR library. */
         aos_pool_t *pool;
         /* Create a new memory pool. The second parameter is NULL, which indicates that the pool does not inherit from other memory pools. */
         aos_pool_create(&pool, NULL);
         /* Create and initialize options. This parameter includes global configuration information, such as endpoint, access_key_id, access_key_secret, is_cname, and curl. */
         oss_request_options_t *oss_client_options;
         /* Allocate memory for options in the memory pool. */
         oss_client_options = oss_request_options_create(pool);
         /* Initialize the client option oss_client_options. */
         init_options(oss_client_options);
     
         /* Initialize parameters. */
         aos_string_t bucket;
         aos_string_t object;
         aos_list_t buffer;
         aos_buf_t *content = NULL;
         aos_table_t *headers = NULL;
         aos_table_t *resp_headers = NULL; 
         aos_status_t *resp_status = NULL; 
         /* Assign the data of the char* type to the bucket. */
         aos_str_set(&bucket, bucket_name);
         aos_str_set(&object, object_name);
     
         aos_list_init(&buffer);
         content = aos_buf_pack(oss_client_options->pool, object_content, strlen(object_content));
         aos_list_add_tail(&content->node, &buffer);
     
         /* Upload the file. */
         resp_status = oss_put_object_from_buffer(oss_client_options, &bucket, &object, &buffer, headers, &resp_headers);
         /* Check whether the file is uploaded. */
         if (aos_status_is_ok(resp_status)) {
             printf("put object from buffer succeeded\n");
         } else {
             printf("put object from buffer failed\n");      
         }    
     
         /* Release the memory pool. This is equivalent to releasing the memory allocated for various resources during the request. */
         aos_pool_destroy(pool);
     
         /* Release the previously allocated global resources. */
         aos_http_io_deinitialize();
     
         return 0;
     }            

   • Récupérer un fichier

     #include "oss_api.h"
     #include "aos_http_io.h"
     /* Set yourEndpoint to the endpoint of the region where the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
     const char *endpoint = "yourEndpoint";
     /* Obtain access credentials from environment variables. Before you run this sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set. */  
     const char *access_key_id = getenv("OSS_ACCESS_KEY_ID");
     const char *access_key_secret = getenv("OSS_ACCESS_KEY_SECRET");
     /* The security token (SecurityToken) obtained from STS. */
     const char *sts_token = "yourStsToken";
     /* Specify the bucket name. For example, examplebucket. */
     const char *bucket_name = "examplebucket";
     /* Specify the full path of the object. The full path cannot contain the bucket name. For example, exampledir/exampleobject.txt. */
     const char *object_name = "exampledir/exampleobject.txt";
     void init_options(oss_request_options_t *options)
     {
         options->config = oss_config_create(options->pool);
         /* Initialize the aos_string_t type with a char* string. */
         aos_str_set(&options->config->endpoint, endpoint);
         aos_str_set(&options->config->access_key_id, access_key_id);
         aos_str_set(&options->config->access_key_secret, access_key_secret);
         aos_str_set(&options->config->sts_token, sts_token);
         /* Specify whether a CNAME is used. A value of 0 indicates that a CNAME is not used. */
         options->config->is_cname = 0;
         /* Used to set network parameters, such as the timeout period. */
         options->ctl = aos_http_controller_create(options->pool, 0);
     }
     int main(int argc, char *argv[])
     {
         /* Call the aos_http_io_initialize method at the program entry to initialize global resources, such as the network and memory. */
         if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
             exit(1);
         }
         /* The memory pool (pool) for memory management, which is equivalent to apr_pool_t. Its implementation code is in the APR library. */
         aos_pool_t *pool;
         /* Create a new memory pool. The second parameter is NULL, which indicates that the pool does not inherit from other memory pools. */
         aos_pool_create(&pool, NULL);
         /* Create and initialize options. This parameter includes global configuration information, such as endpoint, access_key_id, access_key_secret, is_cname, and curl. */
         oss_request_options_t *oss_client_options;
         /* Allocate memory for options in the memory pool. */
         oss_client_options = oss_request_options_create(pool);
         /* Initialize the client option oss_client_options. */
         init_options(oss_client_options);
         /* Initialize parameters. */
         aos_string_t bucket;
         aos_string_t object;
         aos_list_t buffer;
         aos_buf_t *content = NULL;
         aos_table_t *params = NULL;
         aos_table_t *headers = NULL;
         aos_table_t *resp_headers = NULL; 
         aos_status_t *resp_status = NULL; 
         char *buf = NULL;
         int64_t len = 0;
         int64_t size = 0;
         int64_t pos = 0;
         aos_str_set(&bucket, bucket_name);
         aos_str_set(&object, object_name);
         aos_list_init(&buffer);
         /* Download the file to the local memory. */
         resp_status = oss_get_object_to_buffer(oss_client_options, &bucket, &object, 
                                      headers, params, &buffer, &resp_headers);
         if (aos_status_is_ok(resp_status)) {
             printf("get object to buffer succeeded\n");
             /* Copy the downloaded content to the buffer. */
             len = aos_buf_list_len(&buffer);
             buf = aos_pcalloc(pool, len + 1);
             buf[len] = '\0';
             aos_list_for_each_entry(aos_buf_t, content, &buffer, node) {
             size = aos_buf_size(content);
                 memcpy(buf + pos, content->pos, size);
                 pos += size;
             }
         }
         else {
             printf("get object to buffer failed\n");  
         }
         /* Release the memory pool. This is equivalent to releasing the memory allocated for various resources during the request. */
         aos_pool_destroy(pool);
         /* Release the previously allocated global resources. */
         aos_http_io_deinitialize();
         return 0;
     }

Utiliser une URL présignée pour autoriser un accès temporaire