Object Storage Service:OSS C++ SDK V2

Prérequis

• Un compilateur C++17 ou ultérieur (GCC 7+, Clang 5+ ou MSVC 2017+).

• CMake 3.15 ou ultérieur.

Exécutez la commande cmake --version pour vérifier votre version de CMake. Si CMake n'est pas installé ou si la version est antérieure à la 3.15, téléchargez et installez CMake .

Installation du SDK

L'utilisation de vcpkg est la méthode d'installation recommandée.

vcpkg install alibabacloud-oss-cpp-sdk-v2[curl]

# On Windows, you can use WinHTTP as the HTTP transport layer instead.
vcpkg install alibabacloud-oss-cpp-sdk-v2[winhttp]

git clone https://github.com/aliyun/alibabacloud-oss-cpp-sdk-v2.git
vcpkg install alibabacloud-oss-cpp-sdk-v2[curl] --overlay-ports=alibabacloud-oss-cpp-sdk-v2/vcpkg --head

git clone https://github.com/aliyun/alibabacloud-oss-cpp-sdk-v2.git
cd alibabacloud-oss-cpp-sdk-v2
mkdir build && cd build
cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local
cmake --build . --target install

Ajoutez la dépendance au fichier CMakeLists.txt de votre projet :

cmake_minimum_required(VERSION 3.15)
project(my-app)

find_package(alibabacloud_oss_v2 REQUIRED)

add_executable(MyApp main.cpp)
target_link_libraries(MyApp PRIVATE alibabacloud_oss_v2::oss)

Configuration des informations d'identification d'accès

Définissez des variables d'environnement contenant la paire AccessKey de votre utilisateur RAM.

Dans la console RAM , créez un utilisateur RAM et générez une AccessKey permanente . Enregistrez l'AccessKey, puis accordez l'autorisation AliyunOSSFullAccess à l'utilisateur.

Initialisation du client

Le SDK prend en charge trois modes de requête : OSSClient (synchrone), OSSClient (asynchrone) (basé sur un pool de threads) et OSSAsyncClient (asynchrone) (async natif). Les exemples suivants utilisent ListBuckets pour illustrer chaque mode.

#include <iostream>
#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();

    oss::OSSClient client(conf);

    auto outcome = client.listBuckets(
        oss::models::ListBucketsRequest());

    if (!outcome.has_value()) {
        auto& err = outcome.error();
        std::cerr << "Error Code: " << err.getCode() << std::endl;
        std::cerr << "Error Message: " << err.getMessage() << std::endl;
        std::cerr << "Request ID: " << err.getRequestId() << std::endl;
        return 1;
    }

    auto& result = outcome.value();
    for (auto& bucket : result.getBuckets()) {
        std::cout << "bucket: name:" << bucket.name
                  << ", region:" << bucket.region
                  << ", storageClass:" << bucket.storageClass
                  << std::endl;
    }

    return 0;
}

#include <future>
#include <iostream>
#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"
#include "alibabacloud/oss2/utils/DefaultExecutor.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
    // Key: Configure a thread pool to enable asyncCall() support for OSSClient.
    conf.executor = std::make_shared<oss::DefaultExecutor>();

    oss::OSSClient client(conf);

    // Asynchronous call that returns a std::future.
    auto future = client.asyncCall(oss::models::ListBucketsRequest());

    // Wait for the result by using get() (future pattern).
    auto outcome = future.get();
    if (!outcome.has_value()) {
        auto& err = outcome.error();
        std::cerr << "Error Code: " << err.getCode() << std::endl;
        std::cerr << "Error Message: " << err.getMessage() << std::endl;
        return 1;
    }

    auto& result = outcome.value();
    for (auto& bucket : result.getBuckets()) {
        std::cout << "bucket: name:" << bucket.name
                  << ", region:" << bucket.region << std::endl;
    }
    return 0;
}

#include <iostream>
#include <thread>
#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSAsyncClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();

    auto client = std::make_shared<oss::OSSAsyncClient>(conf);

    client->listBucketsAsync(
        oss::models::ListBucketsRequest(),
        oss::ListBucketsAsyncCallback([](oss::ListBucketsOutcome outcome) {
            if (!outcome.has_value()) {
                auto& err = outcome.error();
                std::cerr << "Error Code: " << err.getCode() << std::endl;
                std::cerr << "Error Message: " << err.getMessage() << std::endl;
                return;
            }

            auto& result = outcome.value();
            for (auto& bucket : result.getBuckets()) {
                std::cout << "bucket: name:" << bucket.name
                          << ", region:" << bucket.region
                          << ", storageClass:" << bucket.storageClass
                          << std::endl;
            }
        }));

    // Wait for the asynchronous operation to complete.
    std::this_thread::sleep_for(std::chrono::seconds(5));

    return 0;
}

Utiliser un domaine personnalisé

Un domaine personnalisé permet la prévisualisation des fichiers depuis un navigateur et la diffusion accélérée par CDN.

Avant d'exécuter l'exemple de code, remplacez <region-id> par un ID de région réel issu de la liste des régions et endpoints , tel que ap-southeast-1 .

#include <iostream>
#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.endpoint = "https://your-custom-domain.com";
    conf.useCName = true;
    conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();

    oss::OSSClient client(conf);

    // Perform operations using the custom domain.
    auto outcome = client.putObject(
        oss::models::PutObjectRequest()
            .setBucket("your-bucket")
            .setKey("your-key")
            .setBody(oss::RequestBody::fromString("Hello, OSS!")));

    if (!outcome.has_value()) {
        auto& err = outcome.error();
        std::cerr << "Error: " << err.getMessage() << std::endl;
        return 1;
    }

    std::cout << "Upload successful" << std::endl;
    return 0;
}

Contrôle des délais d'expiration

Utilisez connectTimeout et readWriteTimeout pour configurer les délais d'expiration de la connexion et de lecture/écriture en millisecondes.

auto conf = oss::ClientConfiguration::loadDefault();
conf.region = "<region-id>";
conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
// Set the connection timeout to 10 seconds.
conf.connectTimeout = 10000;
// Set the read/write timeout to 30 seconds.
conf.readWriteTimeout = 30000;

oss::OSSClient client(conf);

Politique de nouvelle tentative

Le gestionnaire intégré StandardRetryer utilise une stratégie FullJitterBackoff avec un maximum de 3 tentatives par défaut. Utilisez retryMaxAttempts pour ajuster cette valeur.

auto conf = oss::ClientConfiguration::loadDefault();
conf.region = "<region-id>";
conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
// Set the maximum number of retries to 5.
conf.retryMaxAttempts = 5;

oss::OSSClient client(conf);

Exemple de stratégie de nouvelle tentative personnalisée : CustomRetryStrategy.cpp.

Protocole HTTP/HTTPS

Le protocole HTTPS est utilisé par défaut. Pour utiliser le protocole HTTP, définissez disableSsl sur true.

auto conf = oss::ClientConfiguration::loadDefault();
conf.region = "<region-id>";
conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
// Use the HTTP protocol.
conf.disableSsl = true;

oss::OSSClient client(conf);

Utiliser un endpoint interne

Lorsqu'il est déployé sur ECS, utilisez un endpoint interne pour éviter les coûts liés au trafic du réseau public.

auto conf = oss::ClientConfiguration::loadDefault();
conf.region = "<region-id>";
conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
// Use an internal endpoint.
conf.useInternalEndpoint = true;

oss::OSSClient client(conf);

Utiliser un endpoint d'accélération de transfert

Utilisez un endpoint d'accélération de transfert pour les transferts de données sur de longues distances.

auto conf = oss::ClientConfiguration::loadDefault();
conf.region = "<region-id>";
conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
// Use a transfer acceleration endpoint.
conf.useAccelerateEndpoint = true;

oss::OSSClient client(conf);

Utiliser un domaine personnalisé (CNAME)

Accédez à OSS en utilisant un domaine personnalisé (CNAME).

auto conf = oss::ClientConfiguration::loadDefault();
conf.region = "<region-id>";
conf.credentialsProvider = std::make_shared<oss::EnvironmentVariableCredentialsProvider>();
conf.endpoint = "https://your-custom-domain.com";
conf.useCName = true;

oss::OSSClient client(conf);

Personnaliser le transport HTTP

Le SDK utilise cURL par défaut. Remplacez-le via httpTransport. WinHTTP est également pris en charge sous Windows.

Exemples de transport personnalisé : CurlCustomConfig.cpp et WinHttpCustomConfig.cpp.

Clé d'accès d'utilisateur RAM

Utilisez la clé d'accès d'un utilisateur RAM pour les applications dans un environnement sécurisé et non exposé à Internet.

#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = std::make_shared<oss::StaticCredentialsProvider>(
        "YOUR_ACCESS_KEY_ID", "YOUR_ACCESS_KEY_SECRET");

    oss::OSSClient client(conf);
    // Use the client to perform operations.
    return 0;
}

Identifiants temporaires STS

Les identifiants temporaires STS se composent d'un ID de clé d'accès, d'un secret de clé d'accès et d'un jeton de sécurité. Vous devez gérer et actualiser manuellement ce jeton.

#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = std::make_shared<oss::StaticCredentialsProvider>(
        "STS_ACCESS_KEY_ID", "STS_ACCESS_KEY_SECRET", "STS_SECURITY_TOKEN");

    oss::OSSClient client(conf);
    // Use the client to perform operations.
    return 0;
}

RAMRoleARN, ECSRAMRole ou OIDCRoleARN

Pour les méthodes d'identification telles que RAMRoleARN, ECSRAMRole et OIDCRoleARN, nous recommandons d'utiliser la bibliothèque alibabacloud-credentials-cpp avec le fournisseur CredentialsProviderFunc.

1. Installez la dépendance.

   vcpkg install alibabacloud-credentials-cpp

2. Ajoutez la dépendance dans votre fichier CMakeLists.txt.

   find_package(alibabacloud_credentials REQUIRED)

3. Intégrez la bibliothèque en utilisant CredentialsProviderFunc.

   RAMRoleARN

   #include "alibabacloud/oss2/ClientConfiguration.h"
   #include "alibabacloud/oss2/OSSClient.h"
   #include "alibabacloud/oss2/credentials/CredentialsProvider.h"
   #include <darabonba/core/Client.hpp>
   #include <alibabacloud/credential.hpp>
   
   namespace oss = alibabacloud::oss2;
   
   int main() {
       auto credConfig = std::make_shared<Alibabacloud_Credential::Config>();
       // The credential type must be ram_role_arn.
       credConfig->type = std::make_shared<std::string>("ram_role_arn");
       // The access key ID of the RAM user. To avoid hardcoding, we recommend injecting this value through the ALIBABA_CLOUD_ACCESS_KEY_ID environment variable.
       credConfig->accessKeyId = std::make_shared<std::string>("YOUR_ACCESS_KEY_ID");
       // The access key secret of the RAM user. To avoid hardcoding, we recommend injecting this value through the ALIBABA_CLOUD_ACCESS_KEY_SECRET environment variable.
       credConfig->accessKeySecret = std::make_shared<std::string>("YOUR_ACCESS_KEY_SECRET");
       // The ARN of the RAM role to assume. Example: acs:ram::123456789012****:role/adminrole
       // You can also set this value by using the ALIBABA_CLOUD_ROLE_ARN environment variable.
       credConfig->roleArn = std::make_shared<std::string>("YOUR_ROLE_ARN");
       // The role session name, used for auditing purposes. You can also set this value by using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
       credConfig->roleSessionName = std::make_shared<std::string>("your-session-name");
       // (Optional) Further restrict permissions with a policy. This parameter is not required.
       // Example: {"Statement":[{"Action":["oss:GetObject"],"Effect":"Allow","Resource":["*"]}],"Version":"1"}
       // credConfig->policy = std::make_shared<std::string>("<Policy>");
       // (Optional) The role session duration in seconds. Default: 3600 (1 hour). This parameter is not required.
       // credConfig->roleSessionExpiration = std::make_shared<long>(3600);
   
       auto credClient = std::make_shared<Alibabacloud_Credential::Client>(credConfig);
   
       auto conf = oss::ClientConfiguration::loadDefault();
       conf.region = "<region-id>";
       conf.credentialsProvider = std::make_shared<oss::CredentialsProviderFunc>(
           [credClient]() -> oss::Credentials {
               auto cred = credClient->getCredential();
               auto ak = cred.getAccessKeyId();
               auto sk = cred.getAccessKeySecret();
               if (ak.empty() || sk.empty()) {
                   return oss::Credentials::withRetryableError(
                       "failed to get credentials from alibabacloud-credentials-cpp");
               }
               auto token = cred.getSecurityToken();
               return oss::Credentials(std::move(ak), std::move(sk), std::move(token));
           });
   
       oss::OSSClient client(conf);
       // Use the client to perform operations.
       return 0;
   }

   ECSRAMRole

   #include "alibabacloud/oss2/ClientConfiguration.h"
   #include "alibabacloud/oss2/OSSClient.h"
   #include "alibabacloud/oss2/credentials/CredentialsProvider.h"
   #include <darabonba/core/Client.hpp>
   #include <alibabacloud/credential.hpp>
   
   namespace oss = alibabacloud::oss2;
   
   int main() {
       auto credConfig = std::make_shared<Alibabacloud_Credential::Config>();
       // The credential type must be ecs_ram_role.
       credConfig->type = std::make_shared<std::string>("ecs_ram_role");
       // The name of the RAM role granted to the ECS instance. This parameter is optional.
       // If you do not set it, the SDK automatically retrieves it from the metadata service.
       // We strongly recommend setting this parameter explicitly to reduce requests to the metadata service.
       credConfig->roleName = std::make_shared<std::string>("YOUR_ECS_ROLE_NAME");
   
       auto credClient = std::make_shared<Alibabacloud_Credential::Client>(credConfig);
   
       auto conf = oss::ClientConfiguration::loadDefault();
       conf.region = "<region-id>";
       conf.credentialsProvider = std::make_shared<oss::CredentialsProviderFunc>(
           [credClient]() -> oss::Credentials {
               auto cred = credClient->getCredential();
               auto ak = cred.getAccessKeyId();
               auto sk = cred.getAccessKeySecret();
               if (ak.empty() || sk.empty()) {
                   return oss::Credentials::withRetryableError(
                       "failed to get credentials from alibabacloud-credentials-cpp");
               }
               auto token = cred.getSecurityToken();
               return oss::Credentials(std::move(ak), std::move(sk), std::move(token));
           });
   
       oss::OSSClient client(conf);
       // Use the client to perform operations.
       return 0;
   }

   OIDCRoleARN

   #include "alibabacloud/oss2/ClientConfiguration.h"
   #include "alibabacloud/oss2/OSSClient.h"
   #include "alibabacloud/oss2/credentials/CredentialsProvider.h"
   #include <darabonba/core/Client.hpp>
   #include <alibabacloud/credential.hpp>
   
   namespace oss = alibabacloud::oss2;
   
   int main() {
       auto credConfig = std::make_shared<Alibabacloud_Credential::Config>();
       // The credential type must be oidc_role_arn.
       credConfig->type = std::make_shared<std::string>("oidc_role_arn");
       // The ARN of the RAM role to assume. You can also set this value by using the ALIBABA_CLOUD_ROLE_ARN environment variable.
       credConfig->roleArn = std::make_shared<std::string>("YOUR_ROLE_ARN");
       // The ARN of the OIDC identity provider. You can also set this value by using the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
       credConfig->oidcProviderArn = std::make_shared<std::string>("YOUR_OIDC_PROVIDER_ARN");
       // The path to the OIDC token file, which is automatically mounted into the pod by RRSA. You can also set this value by using the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
       credConfig->oidcTokenFilePath = std::make_shared<std::string>("/var/run/secrets/tokens/oidc-token");
       // The role session name, used for auditing purposes. You can also set this value by using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
       credConfig->roleSessionName = std::make_shared<std::string>("your-session-name");
       // (Optional) Further restrict permissions with a policy. This parameter is not required.
       // credConfig->policy = std::make_shared<std::string>("<Policy>");
   
       auto credClient = std::make_shared<Alibabacloud_Credential::Client>(credConfig);
   
       auto conf = oss::ClientConfiguration::loadDefault();
       conf.region = "<region-id>";
       conf.credentialsProvider = std::make_shared<oss::CredentialsProviderFunc>(
           [credClient]() -> oss::Credentials {
               auto cred = credClient->getCredential();
               auto ak = cred.getAccessKeyId();
               auto sk = cred.getAccessKeySecret();
               if (ak.empty() || sk.empty()) {
                   return oss::Credentials::withRetryableError(
                       "failed to get credentials from alibabacloud-credentials-cpp");
               }
               auto token = cred.getSecurityToken();
               return oss::Credentials(std::move(ak), std::move(sk), std::move(token));
           });
   
       oss::OSSClient client(conf);
       // Use the client to perform operations.
       return 0;
   }

   Plus d'exemples d'identifiants : exemples d'identifiants.

Accès anonyme

Accédez aux compartiments et objets publics (public-read) sans utiliser d'identifiants.

#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

namespace oss = alibabacloud::oss2;

int main() {
    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = std::make_shared<oss::AnonymousCredentialsProvider>();

    oss::OSSClient client(conf);
    // Use the client to perform operations.
    return 0;
}

Fournisseur d'identifiants personnalisé

Implémentez une logique personnalisée de récupération des identifiants avec CredentialsProviderFunc.

#include "alibabacloud/oss2/ClientConfiguration.h"
#include "alibabacloud/oss2/OSSClient.h"
#include "alibabacloud/oss2/credentials/CredentialsProvider.h"

#include <cstdlib>

namespace oss = alibabacloud::oss2;

// Example: Load credentials from custom environment variables or a configuration file.
static oss::Credentials loadCredentialsFromCustomSource() {
    // In a real-world application, you can retrieve credentials from various sources:
    //   - A configuration file (such as ~/.ossrc)
    //   - A key management service (such as HashiCorp Vault or KMS)
    //   - A metadata service
    //   - A database
    const char* ak = std::getenv("MY_APP_ACCESS_KEY_ID");
    const char* sk = std::getenv("MY_APP_ACCESS_KEY_SECRET");
    const char* token = std::getenv("MY_APP_SESSION_TOKEN");

    if (!ak || !sk) {
        // The error message propagates to OperationError::getMessage().
        return oss::Credentials::withError(
            "MY_APP_ACCESS_KEY_ID and MY_APP_ACCESS_KEY_SECRET must be set");
        // For transient failures, such as network timeouts, use withRetryableError.
        // The SDK automatically retries credential retrieval.
        // return oss::Credentials::withRetryableError("...");
    }

    return oss::Credentials(ak, sk, token ? token : "");
}

int main() {
    // The custom credential provider function is called every time credentials are required,
    // allowing you to implement rotation, refresh, or caching logic.
    auto provider = std::make_shared<oss::CredentialsProviderFunc>(
        loadCredentialsFromCustomSource);

    auto conf = oss::ClientConfiguration::loadDefault();
    conf.region = "<region-id>";
    conf.credentialsProvider = provider;

    oss::OSSClient client(conf);
    // Use the client to perform operations.
    return 0;
}

Convention de nommage des API

Les noms de méthode utilisent le style camelCase. Chaque opération prend un paramètre <OperationName>Request et renvoie un résultat <OperationName>Outcome (de type Outcome<Result, Error>).

OSSClient (synchrone) :

OutcomeType operationName(const models::OperationNameRequest& request, const OperationOptions* options = nullptr)

OSSAsyncClient (asynchrone natif) :

void operationNameAsync(const models::OperationNameRequest& request, const OperationNameAsyncCallback& callback, const OperationOptions* options = nullptr)

Modes d'appel

Annulation d'une requête

Pour annuler des opérations de longue durée avec un CancellationToken, transmettez un cancellationToken dans les OperationOptions. Le SDK C++ V2 pour OSS propose deux modes d'annulation :

// Cancel the request from another thread.
auto cts = oss::CancellationTokenSource::create();

oss::OperationOptions opts;
opts.cancellationToken = cts->getToken();

// Start the request in another thread.
auto future = std::async([&]() {
    return client.getObject(request, &opts);
});

// Cancel from the current thread.
cts->cancel();

// Set a 30-second timeout for automatic cancellation.
auto cts = oss::CancellationTokenSource::create();
cts->cancelAfter(std::chrono::seconds(30));

oss::OperationOptions opts;
opts.cancellationToken = cts->getToken();

auto outcome = client.getObject(request, &opts);

Gestion des erreurs

Le SDK C++ V2 pour OSS utilise le type Outcome<Result, Error>, compatible avec std::expected. Appelez has_value() pour vérifier le succès de l'opération. En cas de succès, récupérez le résultat avec value() ou en déréférençant l'objet outcome (*outcome). Sinon, récupérez l'objet d'erreur avec error().

auto outcome = client.putObject(request);

if (!outcome.has_value()) {
    auto& err = outcome.error();
    std::cerr << "Error code: " << err.getCode() << std::endl;
    std::cerr << "Error message: " << err.getMessage() << std::endl;
    std::cerr << "EC: " << err.getEC() << std::endl;
    std::cerr << "Request ID: " << err.getRequestId() << std::endl;
    std::cerr << "Request target: " << err.getRequestTarget() << std::endl;
}

Lors de la compilation avec l'option -DUSE_STD_EXPECTED=ON (C++23), Outcome devient un alias de type pour std::expected, qui prend en charge les opérations monadiques telles que .and_then(), .transform() et .or_else().