how to select and configure access credentials for tablestore - Tablestore

Les exigences en matière de sécurité, de validité et de rotation des identifiants varient selon l'environnement de déploiement. Choisissez une méthode de configuration des identifiants adaptée à votre cas d'usage afin d'équilibrer la sécurité et les coûts de maintenance.

Choisir un type d'identifiant

Tablestore prend en charge plusieurs types d'identifiants, notamment les paires AccessKey et les jetons STS. Chaque méthode cible un scénario de déploiement spécifique et une disponibilité du SDK.

Méthode d'identification

Cas d'utilisation

Nécessite une paire AccessKey ou un jeton STS préconfiguré

Identifiant sous-jacent

Validité

Méthode de rotation ou d'actualisation

Prise en charge par le SDK

Utiliser une paire AccessKey d'un utilisateur RAM

Applications s'exécutant dans des environnements sécurisés et stables, présentant un faible risque d'attaques externes et ne nécessitant pas de rotation fréquente des identifiants pour un accès à long terme aux services cloud.

Oui

Paire AccessKey

Long terme

Rotation manuelle

Java, Go, Python, Node.js, .NET, PHP

Utiliser des identifiants temporaires STS

Applications s'exécutant dans des environnements non fiables et nécessitant un contrôle sur la validité de l'accès et les autorisations.

Oui

Jeton STS

Temporaire

Actualisation manuelle

Java, Go, Python, Node.js, PHP

Utiliser RAMRoleARN

Applications nécessitant une autorisation inter-comptes pour accéder aux services cloud.

Oui

Jeton STS

Temporaire

Actualisation automatique

Java

Utiliser ECSRAMRole

Applications s'exécutant sur des instances Elastic Compute Service (ECS), des instances Elastic Container Instance (ECI) ou des nœuds de travail Container Service for Kubernetes (ACK).

Non

Jeton STS

Temporaire

Actualisation automatique

Java

Utiliser OIDCRoleARN

Applications non fiables s'exécutant sur des nœuds de travail ACK.

Non

Jeton STS

Temporaire

Actualisation automatique

Java

Utiliser les identifiants du contexte Function Compute

Applications s'exécutant dans Function Compute.

Non

Jeton STS

Temporaire

Aucune actualisation requise

Java, Python

Utiliser CredentialsURI

Applications devant obtenir des identifiants depuis un système externe.

Non

Jeton STS

Temporaire

Actualisation automatique

Java

Utiliser une paire AccessKey à rotation automatique

Applications s'exécutant dans des environnements exposés au risque de fuite de paires AccessKey et nécessitant une rotation fréquente des identifiants pour un accès à long terme aux services cloud.

Non

Paire AccessKey

Long terme

Rotation automatique

Java

Utiliser des identifiants personnalisés

Récupération personnalisée des identifiants lorsque aucune des méthodes précédentes ne répond à vos besoins.

Personnalisé

Java

Utiliser une clé API

Intégration d'applications d'IA avec Knowledge Store et Memory Store, sans avoir besoin de gérer des paires AccessKey.

Non

Clé API

Configurable

Révocation et recréation manuelles

Python, TypeScript

Configurer les identifiants

Après avoir choisi un type d'identifiant, consultez la section correspondante pour obtenir des instructions détaillées et des exemples de code.

Utiliser une paire AccessKey d'un utilisateur RAM

Configurez les identifiants à l'aide de la paire AccessKey (AccessKey ID et AccessKey Secret) d'un utilisateur RAM. Cette méthode nécessite une maintenance manuelle de la paire AccessKey et présente un risque de sécurité plus élevé.

Important

Un compte Alibaba Cloud dispose d'autorisations complètes sur toutes les ressources. Si la paire AccessKey d'un compte Alibaba Cloud est compromise, toutes les ressources du compte sont exposées. Utilisez la paire AccessKey d'un utilisateur RAM disposant des autorisations minimales requises. Pour obtenir la paire AccessKey d'un utilisateur RAM, consultez Accéder à Tablestore avec la paire AccessKey d'un utilisateur RAM.

Configurez la paire AccessKey à l'aide de variables d'environnement ou d'identifiants statiques.

Variables d'environnement

Configurez les variables d'environnement. Après les avoir définies, redémarrez votre IDE, CLI, applications de bureau et services en arrière-plan pour charger les variables d'environnement mises à jour.

Linux

Ajoutez les variables d'environnement au fichier ~/.bashrc.

echo "export TABLESTORE_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.bashrc
echo "export TABLESTORE_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.bashrc

Appliquez les modifications.
```
source ~/.bashrc
```

Vérifiez les variables d'environnement.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

macOS

Vérifiez le type de shell par défaut.
```
echo $SHELL
```

Procédez en fonction du type de shell par défaut.

Zsh

Ajoutez les variables d'environnement au fichier ~/.zshrc.

echo "export TABLESTORE_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.zshrc
echo "export TABLESTORE_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.zshrc

Appliquez les modifications.
```
source ~/.zshrc
```

Vérifiez les variables d'environnement.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

Bash

Ajoutez les variables d'environnement au fichier ~/.bash_profile.

echo "export TABLESTORE_ACCESS_KEY_ID='YOUR_ACCESS_KEY_ID'" >> ~/.bash_profile
echo "export TABLESTORE_ACCESS_KEY_SECRET='YOUR_ACCESS_KEY_SECRET'" >> ~/.bash_profile

Appliquez les modifications.
```
source ~/.bash_profile
```

Vérifiez les variables d'environnement.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

Windows

CMD

Définissez les variables d'environnement dans CMD.

setx TABLESTORE_ACCESS_KEY_ID "YOUR_ACCESS_KEY_ID"
setx TABLESTORE_ACCESS_KEY_SECRET "YOUR_ACCESS_KEY_SECRET"

Redémarrez CMD et exécutez les commandes suivantes pour vérifier que les variables d'environnement sont définies.
```
echo %TABLESTORE_ACCESS_KEY_ID%
echo %TABLESTORE_ACCESS_KEY_SECRET%
```

PowerShell

Définissez les variables d'environnement dans PowerShell.

[Environment]::SetEnvironmentVariable("TABLESTORE_ACCESS_KEY_ID", "YOUR_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
[Environment]::SetEnvironmentVariable("TABLESTORE_ACCESS_KEY_SECRET", "YOUR_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)

Vérifiez les variables d'environnement.

[Environment]::GetEnvironmentVariable("TABLESTORE_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
[Environment]::GetEnvironmentVariable("TABLESTORE_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)

Transmettez les informations d'identification via les variables d'environnement.

Java

import com.alicloud.openservices.tablestore.core.auth.CredentialsProviderFactory;
import com.alicloud.openservices.tablestore.core.auth.EnvironmentVariableCredentialsProvider;

public class AkDemoTest {
    public static void main(String[] args) throws Exception {
        {
            // Example 1: Obtain credentials from environment variables
            EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
            // Use credentialsProvider for subsequent operations...
        }
        {
            // Example 2: Obtain the accessKeyId and accessKeySecret from environment variables
            final String accessKeyId = System.getenv("TABLESTORE_ACCESS_KEY_ID");
            final String accessKeySecret = System.getenv("TABLESTORE_ACCESS_KEY_SECRET");
            // Use the accessKeyId and accessKeySecret for subsequent operations...
        }
    }
}

Python

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

access_key_id = os.getenv("TABLESTORE_ACCESS_KEY_ID")
access_key_secret = os.getenv("TABLESTORE_ACCESS_KEY_SECRET")

Go

accessKeyId := os.Getenv("TABLESTORE_ACCESS_KEY_ID")
accessKeySecret := os.Getenv("TABLESTORE_ACCESS_KEY_SECRET")

Node.js

var accessKeyId = process.env.TABLESTORE_ACCESS_KEY_ID;
var secretAccessKey = process.env.TABLESTORE_ACCESS_KEY_SECRET;

PHP

$accessKeyId = getenv('TABLESTORE_ACCESS_KEY_ID');
$accessKeySecret = getenv('TABLESTORE_ACCESS_KEY_SECRET');

.NET

// Obtain access credentials from environment variables.
var AccessKeyId = Environment.GetEnvironmentVariable("TABLESTORE_ACCESS_KEY_ID");
var AccessKeySecret = Environment.GetEnvironmentVariable("TABLESTORE_ACCESS_KEY_SECRET");

Identifiants statiques

Référencez les identifiants à partir de variables dans votre code. Ces variables sont renseignées avec les valeurs réelles des identifiants provenant de variables d'environnement, de fichiers de configuration ou d'autres sources de données externes au moment de l'exécution.

L'exemple suivant utilise des identifiants statiques issus d'un fichier de configuration.

Créez un fichier de configuration nommé config.ini.

[configName]
TABLESTORE_ACCESS_KEY_ID = your_access_key_id
TABLESTORE_ACCESS_KEY_SECRET = your_access_key_secret

Transmettez les informations d'identification à partir du fichier de configuration.

Java

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentialProvider;
import java.io.FileInputStream;
import java.util.Properties;

public class AkDemoTest {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        // Set the path to the config.ini file. Use the actual path.
        String configFilePath = "config.ini";

        // Read the configuration file
        FileInputStream input = new FileInputStream(configFilePath);
        properties.load(input);
        input.close();

        // Obtain the AccessKey ID and AccessKey Secret from the configuration file
        String accessKeyId = properties.getProperty("TABLESTORE_ACCESS_KEY_ID");
        String accessKeySecret = properties.getProperty("TABLESTORE_ACCESS_KEY_SECRET");

        CredentialsProvider credentialsProvider = new DefaultCredentialProvider(accessKeyId, accessKeySecret);

        // Use credentialsProvider for subsequent operations...
    }
}

Python

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

# Read the configuration file
config = configparser.ConfigParser()
# Assume config.ini is in the same directory as the script. Use the actual path.
config.read('config.ini')

# Obtain the AccessKey ID and AccessKey Secret from the configuration file
access_key_id = config.get('configName', 'TABLESTORE_ACCESS_KEY_ID')
access_key_secret = config.get('configName', 'TABLESTORE_ACCESS_KEY_SECRET')

Go

// Read the configuration file. Use the actual path.
config, err := ini.Load("config.ini")
if err != nil {
    fmt.Println("Failed to read the configuration file:", err)
}

// Obtain the AccessKey ID and AccessKey Secret from the configuration file
access_key_id := config.Section("configName").Key("TABLESTORE_ACCESS_KEY_ID").String()
access_key_secret := config.Section("configName").Key("TABLESTORE_ACCESS_KEY_SECRET").String()

PHP

try {
    // Read the configuration file. Assume config.ini is in the same directory as the script. Use the actual path.
    $config = parse_ini_file('config.ini');
    // Obtain the AccessKey ID and AccessKey Secret
    $accessKeyId = $config['TABLESTORE_ACCESS_KEY_ID'];
    $accessKeySecret = $config['TABLESTORE_ACCESS_KEY_SECRET'];
}catch (Exception $e) {
    printf($e->getMessage() . "\n");
    return;
}

Utiliser des identifiants temporaires STS

Configurez les identifiants à l'aide des identifiants d'identité temporaires (AccessKey ID, AccessKey Secret et Security Token) obtenus auprès du Security Token Service (STS). Cette méthode nécessite une maintenance manuelle du jeton STS et présente un risque de sécurité plus élevé. Pour accéder à Tablestore plusieurs fois avec des identifiants temporaires, vous devez actualiser manuellement le jeton STS. Pour obtenir des identifiants temporaires STS, consultez Utiliser des identifiants temporaires STS pour accéder à Tablestore.

Configurez les identifiants temporaires STS à l'aide de variables d'environnement ou d'identifiants statiques.

Variables d'environnement

Linux

Ajoutez les variables d'environnement au fichier ~/.bashrc.

echo "export TABLESTORE_ACCESS_KEY_ID='YOUR_STS_ACCESS_KEY_ID'" >> ~/.bashrc
echo "export TABLESTORE_ACCESS_KEY_SECRET='YOUR_STS_ACCESS_KEY_SECRET'" >> ~/.bashrc
echo "export TABLESTORE_SESSION_TOKEN='YOUR_STS_TOKEN'" >> ~/.bashrc

Appliquez les modifications.
```
source ~/.bashrc
```

Vérifiez les variables d'environnement.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

macOS

Vérifiez le type de shell par défaut.
```
echo $SHELL
```

Procédez en fonction du type de shell par défaut.

Zsh

Ajoutez les variables d'environnement au fichier ~/.zshrc.

echo "export TABLESTORE_ACCESS_KEY_ID='YOUR_STS_ACCESS_KEY_ID'" >> ~/.zshrc
echo "export TABLESTORE_ACCESS_KEY_SECRET='YOUR_STS_ACCESS_KEY_SECRET'" >> ~/.zshrc
echo "export TABLESTORE_SESSION_TOKEN='YOUR_STS_TOKEN'" >> ~/.zshrc

Appliquez les modifications.
```
source ~/.zshrc
```

Vérifiez les variables d'environnement.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

Bash

Ajoutez les variables d'environnement au fichier ~/.bash_profile.

echo "export TABLESTORE_ACCESS_KEY_ID='YOUR_STS_ACCESS_KEY_ID'" >> ~/.bash_profile
echo "export TABLESTORE_ACCESS_KEY_SECRET='YOUR_STS_ACCESS_KEY_SECRET'" >> ~/.bash_profile
echo "export TABLESTORE_SESSION_TOKEN='YOUR_STS_TOKEN'" >> ~/.bash_profile

Appliquez les modifications.
```
source ~/.bash_profile
```

Vérifiez les variables d'environnement.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

Windows

CMD

Définissez les variables d'environnement dans CMD.

setx TABLESTORE_ACCESS_KEY_ID "YOUR_STS_ACCESS_KEY_ID"
setx TABLESTORE_ACCESS_KEY_SECRET "YOUR_STS_ACCESS_KEY_SECRET"
setx TABLESTORE_SESSION_TOKEN "YOUR_STS_TOKEN"

Redémarrez CMD et exécutez les commandes suivantes pour vérifier que les variables d'environnement sont définies.
```
echo %TABLESTORE_ACCESS_KEY_ID%
echo %TABLESTORE_ACCESS_KEY_SECRET%
echo %TABLESTORE_SESSION_TOKEN%
```

PowerShell

Définissez les variables d'environnement dans PowerShell.

[Environment]::SetEnvironmentVariable("TABLESTORE_ACCESS_KEY_ID", "YOUR_STS_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
[Environment]::SetEnvironmentVariable("TABLESTORE_ACCESS_KEY_SECRET", "YOUR_STS_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)
[Environment]::SetEnvironmentVariable("TABLESTORE_SESSION_TOKEN", "YOUR_STS_TOKEN", [EnvironmentVariableTarget]::User)

Vérifiez les variables d'environnement.

[Environment]::GetEnvironmentVariable("TABLESTORE_ACCESS_KEY_ID", [EnvironmentVariableTarget]::User)
[Environment]::GetEnvironmentVariable("TABLESTORE_ACCESS_KEY_SECRET", [EnvironmentVariableTarget]::User)
[Environment]::GetEnvironmentVariable("TABLESTORE_SESSION_TOKEN", [EnvironmentVariableTarget]::User)

Transmettez les informations d'identification via les variables d'environnement.

Java

import com.alicloud.openservices.tablestore.core.auth.CredentialsProviderFactory;
import com.alicloud.openservices.tablestore.core.auth.EnvironmentVariableCredentialsProvider;

public class StsDemoTest {
    public static void main(String[] args) throws Exception {
        {
            // Example 1: Obtain credentials from environment variables
            EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
            // Use credentialsProvider for subsequent operations...
        }
        {
            // Example 2: Obtain the accessKeyId, accessKeySecret, and securityToken from environment variables
            final String accessKeyId = System.getenv("TABLESTORE_ACCESS_KEY_ID");
            final String accessKeySecret = System.getenv("TABLESTORE_ACCESS_KEY_SECRET");
            final String securityToken = System.getenv("TABLESTORE_SESSION_TOKEN");
            // Use the accessKeyId, accessKeySecret, and securityToken for subsequent operations...
        }
    }
}

Python

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

access_key_id = os.getenv("TABLESTORE_ACCESS_KEY_ID")
access_key_secret = os.getenv("TABLESTORE_ACCESS_KEY_SECRET")
sts_token = os.getenv("TABLESTORE_SESSION_TOKEN")

Go

accessKeyId := os.Getenv("TABLESTORE_ACCESS_KEY_ID")
accessKeySecret := os.Getenv("TABLESTORE_ACCESS_KEY_SECRET")
securityToken := os.Getenv("TABLESTORE_SESSION_TOKEN")

Node.js

var accessKeyId = process.env.TABLESTORE_ACCESS_KEY_ID;
var secretAccessKey = process.env.TABLESTORE_ACCESS_KEY_SECRET;
var stsToken = process.env.TABLESTORE_SESSION_TOKEN;

PHP

$accessKeyId = getenv('TABLESTORE_ACCESS_KEY_ID');
$accessKeySecret = getenv('TABLESTORE_ACCESS_KEY_SECRET');
$securityToken = getenv('TABLESTORE_SESSION_TOKEN');

Identifiants statiques

L'exemple suivant utilise des identifiants statiques issus d'un fichier de configuration.

Créez un fichier de configuration nommé config.ini.

[configName]
TABLESTORE_ACCESS_KEY_ID = your_sts_access_key_id
TABLESTORE_ACCESS_KEY_SECRET = your_sts_access_key_secret
TABLESTORE_SESSION_TOKEN = your_sts_token

Transmettez les informations d'identification à partir du fichier de configuration.

Java

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentialProvider;
import java.io.FileInputStream;
import java.util.Properties;

public class StsDemoTest {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        // Set the path of the config.ini file. Replace the path with the actual path.
        String configFilePath = "config.ini";

        // Read the configuration file.
        FileInputStream input = new FileInputStream(configFilePath);
        properties.load(input);
        input.close();

        // Obtain the AccessKey ID, AccessKey Secret, and security token from the configuration file.
        String accessKeyId = properties.getProperty("TABLESTORE_ACCESS_KEY_ID");
        String accessKeySecret = properties.getProperty("TABLESTORE_ACCESS_KEY_SECRET");
        String securityToken = properties.getProperty("TABLESTORE_SESSION_TOKEN");

        CredentialsProvider credentialsProvider = new DefaultCredentialProvider(accessKeyId, accessKeySecret, securityToken);
        // Use credentialsProvider for subsequent operations...
    }
}

Python

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

# Read the configuration file
config = configparser.ConfigParser()
# Assume config.ini is in the same directory as the script. Use the actual path.
config.read('config.ini')

# Obtain the AccessKey ID, AccessKey Secret, and Security Token from the configuration file
access_key_id = config.get('configName', 'TABLESTORE_ACCESS_KEY_ID')
access_key_secret = config.get('configName', 'TABLESTORE_ACCESS_KEY_SECRET')
security_token = config.get('configName', 'TABLESTORE_SESSION_TOKEN')

Go

// Read the configuration file. Use the actual path.
config, err := ini.Load("config.ini")
if err != nil {
    fmt.Println("Failed to read the configuration file:", err)
}

// Obtain the AccessKey ID, AccessKey Secret, and Security Token from the configuration file
access_key_id := config.Section("configName").Key("TABLESTORE_ACCESS_KEY_ID").String()
access_key_secret := config.Section("configName").Key("TABLESTORE_ACCESS_KEY_SECRET").String()
security_token := config.Section("configName").Key("TABLESTORE_SESSION_TOKEN").String()

PHP

try {
    // Read the configuration file. Assume config.ini is in the same directory as the script. Use the actual path.
    $config = parse_ini_file('config.ini');
    // Obtain the AccessKey ID, AccessKey Secret, and Security Token
    $accessKeyId = $config['TABLESTORE_ACCESS_KEY_ID'];
    $accessKeySecret = $config['TABLESTORE_ACCESS_KEY_SECRET'];
    $securityToken = $config['TABLESTORE_SESSION_TOKEN'];
}catch (Exception $e) {
    printf($e->getMessage() . "\n");
    return;
}

Utiliser RAMRoleARN

Configurez les identifiants avec RAMRoleARN. Cette méthode utilise des jetons STS comme identifiants sous-jacents. Lorsque vous spécifiez le nom de ressource Alibaba Cloud (ARN) d'un rôle RAM, l'outil Credentials demande un jeton STS au service STS et actualise automatiquement le jeton avant l'expiration de la session. Vous pouvez également attribuer une valeur à policy pour restreindre le rôle RAM à un ensemble de permissions plus réduit. Cette méthode nécessite une paire AccessKey, ce qui augmente les risques de sécurité et l'effort de maintenance. Pour obtenir une paire AccessKey, consultez la rubrique Créer une clé AccessKey. Pour obtenir un RAMRoleARN, consultez la rubrique Créer un rôle RAM.

Ajoutez la dépendance credentials.

<!-- https://mvnrepository.com/artifact/com.aliyun/credentials-java -->
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>credentials-java</artifactId>
    <version>0.3.4</version>
</dependency>

Configurez la paire AccessKey et le RAMRoleARN en tant qu'identifiants d'accès.

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentials;
import com.alicloud.openservices.tablestore.core.auth.ServiceCredentials;
import com.aliyun.credentials.models.CredentialModel;

public class RamRoleArnAkDemoTest {

    public static void main(String[] args) {

        com.aliyun.credentials.models.Config config = new com.aliyun.credentials.models.Config();
        // Credential type. Set the value to ram_role_arn.
        config.setType("ram_role_arn");
        // The ARN of the RAM role to assume. Example: acs:ram::123456789012****:role/adminrole. You can also set the RoleArn by using the ALIBABA_CLOUD_ROLE_ARN environment variable.
        config.setRoleArn("<RoleArn>");
        // Obtain the AccessKey ID from an environment variable.
        config.setAccessKeyId(System.getenv().get("TABLESTORE_ACCESS_KEY_ID"));
        // Obtain the AccessKey Secret from an environment variable.
        config.setAccessKeySecret(System.getenv().get("TABLESTORE_ACCESS_KEY_SECRET"));
        // Specify the session name of the RAM role.
        config.setRoleName("roleSessionName");
        // Specify a policy that has fewer permissions. Optional. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
        config.setPolicy("<Policy>");
        // Set the validity period of the role session. Optional.
        config.setRoleSessionExpiration(3600);

        final com.aliyun.credentials.Client credentialsClient = new com.aliyun.credentials.Client(config);

        CredentialsProvider credentialsProvider = new CredentialsProvider(){
            @Override
            public void setCredentials(ServiceCredentials credentials) {
            }

            @Override
            public ServiceCredentials getCredentials() {
                CredentialModel credential = credentialsClient.getCredential();
                return  new DefaultCredentials(credential.getAccessKeyId(), credential.getAccessKeySecret(), credential.getSecurityToken());
            }
        };
        // Use credentialsProvider for subsequent operations...
    }
}

Utiliser ECSRAMRole

Configurez les identifiants avec ECSRAMRole. Cette méthode utilise des jetons STS comme identifiants sous-jacents. ECSRAMRole vous permet d'attacher un rôle à une instance ECS, une instance ECI ou un nœud de travail ACK. Le jeton STS est automatiquement actualisé au sein de l'instance. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine le risque lié à la maintenance manuelle des identifiants. Pour obtenir un ECSRAMRole, consultez la rubrique Créer un rôle RAM.

Ajoutez la dépendance credentials.

<!-- https://mvnrepository.com/artifact/com.aliyun/credentials-java -->
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>credentials-java</artifactId>
    <version>0.3.4</version>
</dependency>

Configurez ECSRAMRole en tant qu'identifiants d'accès.

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentials;
import com.alicloud.openservices.tablestore.core.auth.ServiceCredentials;
import com.aliyun.credentials.models.CredentialModel;

public class EcsRamRoleDemoTest {

    public static void main(String[] args) {

        com.aliyun.credentials.models.Config config = new com.aliyun.credentials.models.Config();
        // Credential type. Set the value to ecs_ram_role.
        config.setType("ecs_ram_role");
        // The name of the RAM role attached to the ECS instance. Optional. If you do not specify this parameter, the role name is automatically retrieved. We recommend that you specify this parameter to reduce the number of requests.
        config.setRoleName("ECSRAMRole");
        // Enable the hardened mode of the ECS instance metadata service (IMDSv2). Optional. We recommend that you enable this parameter to improve the overall system security.
        config.setEnableIMDSv2(true);

        final com.aliyun.credentials.Client credentialsClient = new com.aliyun.credentials.Client(config);

        CredentialsProvider credentialsProvider = new CredentialsProvider(){
            @Override
            public void setCredentials(ServiceCredentials credentials) {
            }

            @Override
            public ServiceCredentials getCredentials() {
                CredentialModel credential = credentialsClient.getCredential();
                return  new DefaultCredentials(credential.getAccessKeyId(), credential.getAccessKeySecret(), credential.getSecurityToken());
            }
        };
        // Use credentialsProvider for subsequent operations...
    }
}

Utiliser OIDCRoleARN

Après avoir configuré un rôle RAM pour un nœud de travail ACK, les applications exécutées dans les pods de ce nœud peuvent obtenir le jeton STS du rôle associé depuis le serveur de métadonnées, de manière similaire aux applications déployées sur des instances ECS. Toutefois, si des applications non fiables s'exécutent sur le cluster, telles que du code soumis par des clients, n'obtenez pas le jeton STS depuis le serveur de métadonnées.

RAM Roles for Service Account (RRSA) offre une isolation des permissions au niveau de l'application. RRSA permet aux applications non fiables d'obtenir en toute sécurité les identifiants requis sans exposer d'autres ressources cloud. Cette méthode utilise des jetons STS comme identifiants sous-jacents. Le cluster ACK crée et monte des fichiers de jetons OIDC pour différents pods d'application et injecte les informations de configuration associées dans des variables d'environnement. L'outil Credentials lit les informations de configuration depuis les variables d'environnement et appelle l'opération AssumeRoleWithOIDC de STS pour obtenir le jeton STS du rôle lié. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine le risque lié à la maintenance manuelle des identifiants. Pour plus d'informations, consultez la rubrique Utiliser RRSA pour le contrôle d'accès au niveau des pods.

Ajoutez la dépendance credentials.

<!-- https://mvnrepository.com/artifact/com.aliyun/credentials-java -->
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>credentials-java</artifactId>
    <version>0.3.4</version>
</dependency>

Configurez le rôle RAM OIDC en tant qu'identifiants d'accès.

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentials;
import com.alicloud.openservices.tablestore.core.auth.ServiceCredentials;
import com.aliyun.credentials.models.CredentialModel;

public class OidcRoleArnDemoTest {

    public static void main(String[] args) {
        com.aliyun.credentials.models.Config config = new com.aliyun.credentials.models.Config();
        // Credential type. Set the value to oidc_role_arn.
        config.setType("oidc_role_arn");
        // The ARN of the RAM role. You can also set the RoleArn by using the ALIBABA_CLOUD_ROLE_ARN environment variable.
        config.setRoleArn("<RoleArn>");
        // The ARN of the OIDC provider. You can also set the OidcProviderArn by using the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
        config.setOidcProviderArn("<OidcProviderArn>");
        // The path of the OIDC token file. You can also set the OidcTokenFilePath by using the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
        config.setOidcTokenFilePath("<OidcTokenFilePath>");
        // The role session name. You can also set the RoleSessionName by using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
        config.setRoleSessionName("<RoleSessionName>");
        // Specify a policy that has fewer permissions. Optional. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
        config.setPolicy("<Policy>");
        // Set the session expiration time.
        config.setRoleSessionExpiration(3600);

        final com.aliyun.credentials.Client credentialsClient = new com.aliyun.credentials.Client(config);

        CredentialsProvider credentialsProvider = new CredentialsProvider() {
            @Override
            public void setCredentials(ServiceCredentials credentials) {
            }

            @Override
            public ServiceCredentials getCredentials() {
                CredentialModel credential = credentialsClient.getCredential();
                return new DefaultCredentials(credential.getAccessKeyId(), credential.getAccessKeySecret(), credential.getSecurityToken());
            }
        };
        // Use credentialsProvider for subsequent operations...
    }
}

Utiliser les identifiants du contexte Function Compute

Configurez les identifiants depuis le contexte Function Compute. Cette méthode utilise des jetons STS comme identifiants sous-jacents. Function Compute endosse le rôle de service configuré pour la fonction afin d'obtenir un jeton STS, qui est transmis au code de la fonction via le paramètre de contexte Credentials. Le jeton est valide pendant 36 heures et ne peut pas être modifié. La durée d'exécution maximale d'une fonction étant de 24 heures, le jeton n'expire pas pendant l'exécution et ne nécessite aucune actualisation. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine le risque lié à la maintenance manuelle des identifiants. Pour accorder à Function Compute les permissions d'accès à Tablestore, consultez la rubrique Utiliser un rôle de fonction pour accéder à d'autres services cloud.

Java

Ajoutez la dépendance du contexte Function Compute.

<!-- https://mvnrepository.com/artifact/com.aliyun.fc.runtime/fc-java-core -->
<dependency>
    <groupId>com.aliyun.fc.runtime</groupId>
    <artifactId>fc-java-core</artifactId>
    <version>1.4.1</version>
</dependency>

Initialisez un fournisseur d'identifiants avec les identifiants du contexte Function Compute.

package example;

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentialProvider;
import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.Credentials;
import com.aliyun.fc.runtime.StreamRequestHandler;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class App implements StreamRequestHandler {

    @Override
    public void handleRequest(
            InputStream inputStream, OutputStream outputStream, Context context) throws IOException {

        // Obtain the credential information. Before you run the code, make sure that the service associated with the function is configured with a role that has Tablestore permissions. We recommend that you use the AliyunFCDefaultRole role.
        Credentials creds = context.getExecutionCredentials();

        // Create a credential provider by using the obtained credentials.
        CredentialsProvider credentialsProvider = new DefaultCredentialProvider(creds.getAccessKeyId(), creds.getAccessKeySecret(), creds.getSecurityToken());

        // Use credentialsProvider for subsequent operations...

        outputStream.write(new String("done").getBytes());
    }
}

Python

Obtenez des identifiants d'accès temporaires depuis le contexte Function Compute.

# -*- coding: utf-8 -*-

def handler(event, context):
    # Obtain credential information. Before you run the code, make sure that the service associated with the function
    # has a role configured with Tablestore permissions. We recommend that you use the AliyunFCDefaultRole role.
    creds = context.credentials

    access_key_id = creds.access_key_id
    access_key_secret = creds.access_key_secret
    security_token = creds.security_token

    # Subsequent operations...

    return 'success'

Utiliser CredentialsURI

Configurez les identifiants avec un CredentialsURI. Cette méthode utilise des jetons STS comme identifiants sous-jacents. L'outil Credentials obtient un jeton STS depuis l'URI que vous fournissez et initialise le client d'identifiants. Cette méthode ne nécessite ni paire AccessKey ni jeton STS, ce qui élimine le risque lié à la maintenance manuelle des identifiants. Le service backend qui répond au CredentialsURI doit implémenter une logique d'actualisation automatique des jetons STS pour garantir que l'application puisse toujours obtenir des identifiants valides.

Pour permettre à l'outil Credentials d'analyser et d'utiliser le jeton STS, l'URI doit respecter le protocole de réponse suivant :
- 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"
}
```

Ajoutez la dépendance credentials.

<!-- https://mvnrepository.com/artifact/com.aliyun/credentials-java -->
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>credentials-java</artifactId>
    <version>0.3.4</version>
</dependency>

Configurez le CredentialsURI en tant qu'identifiants d'accès.

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentials;
import com.alicloud.openservices.tablestore.core.auth.ServiceCredentials;
import com.aliyun.credentials.models.CredentialModel;

public class CredentialsUriDemoTest {
    public static void main(String[] args) {

        com.aliyun.credentials.models.Config config = new com.aliyun.credentials.models.Config();
        // Credential type. Set the value to credentials_uri.
        config.setType("credentials_uri");
        // The URI used to obtain credentials. Format: http://local_or_remote_uri/
        config.setCredentialsUri("<local_or_remote_uri>");

        final com.aliyun.credentials.Client credentialsClient = new com.aliyun.credentials.Client(config);

        CredentialsProvider credentialsProvider = new CredentialsProvider() {
            @Override
            public void setCredentials(ServiceCredentials credentials) {
            }

            @Override
            public ServiceCredentials getCredentials() {
                CredentialModel credential = credentialsClient.getCredential();
                return new DefaultCredentials(credential.getAccessKeyId(), credential.getAccessKeySecret(), credential.getSecurityToken());
            }
        };
        // Use credentialsProvider for subsequent operations...
    }
}

Utiliser une paire AccessKey à rotation automatique

Configurez les identifiants avec une ClientKey. Avec une ClientKey, Key Management Service (KMS) fait pivoter automatiquement la paire AccessKey de l'utilisateur RAM géré selon une planification périodique, convertissant ainsi une paire AccessKey statique en une paire dynamique et réduisant le risque de fuites. KMS prend également en charge la rotation immédiate, ce qui vous permet de remplacer rapidement la paire AccessKey en cas de fuite. Cette méthode ne nécessite aucune maintenance manuelle de la paire AccessKey, ce qui réduit les risques de sécurité et l'effort de maintenance.

Ajoutez la dépendance du client secrets.

<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>alibabacloud-secretsmanager-client</artifactId>
    <version>1.3.7</version>
</dependency>
<dependency>
  <groupId>com.aliyun</groupId>
  <artifactId>aliyun-java-sdk-core</artifactId>
  <version>4.7.0</version>
</dependency>

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

# Access credential type. Set the value to client_key.
credentials_type=client_key

# Decryption password for the Client Key. You can read the password from an environment variable or a file. Configure only one of the following settings.
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>

# Path to the private key file of the Client Key
client_key_private_key_path=<your client key private key file path>

# Region ID of the associated KMS service
cache_client_region_id=[{"regionId":"<regionId>"}]

Transmettez les informations d'identification depuis le fichier de configuration.

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentials;
import com.alicloud.openservices.tablestore.core.auth.ServiceCredentials;
import com.aliyuncs.kms.secretsmanager.client.SecretCacheClient;
import com.aliyuncs.kms.secretsmanager.client.SecretCacheClientBuilder;
import com.aliyuncs.kms.secretsmanager.client.exception.CacheSecretException;
import com.aliyuncs.kms.secretsmanager.client.model.SecretInfo;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;

public class ClientKeyDemoTest {

    public static void main(String[] args) throws CacheSecretException {
        final SecretCacheClient client = SecretCacheClientBuilder.newClient();
        CredentialsProvider credentialsProvider = new CredentialsProvider() {
            @Override
            public void setCredentials(ServiceCredentials credentials) {
            }

            @Override
            public ServiceCredentials getCredentials() {
                try {
                    SecretInfo secretInfo = client.getSecretInfo("<secretName>");
                    JSONObject jsonObject = new JSONObject(secretInfo.getSecretValue());

                    String accessKeyId = jsonObject.getString("AccessKeyId");
                    String accessKeySecret = jsonObject.getString("AccessKeySecret");

                    return new DefaultCredentials(accessKeyId, accessKeySecret);
                } catch (CacheSecretException | JSONException e) {
                    return null;
                }
            }
        };
        // Use credentialsProvider for subsequent operations...
    }
}

Utiliser des identifiants personnalisés

Si aucune des méthodes de configuration d'identifiants précédentes ne répond à vos besoins, implémentez l'interface Credential Providers pour personnaliser la manière dont les identifiants sont fournis. Si l'implémentation sous-jacente utilise des jetons STS, vous devez prendre en charge l'actualisation des identifiants.

import com.alicloud.openservices.tablestore.core.auth.CredentialsProvider;
import com.alicloud.openservices.tablestore.core.auth.DefaultCredentials;
import com.alicloud.openservices.tablestore.core.auth.ServiceCredentials;

public class CustomCredentialProviderDemoTest {

    public static void main(String[] args) {

        CredentialsProvider credentialsProvider = new CredentialsProvider(){

            // Initialize the variable.
            String accessKeyId = null;
            // Initialize the variable.
            String accessKeySecret = null;
            // Initialize the variable.
            // String token = null;

            @Override
            public void setCredentials(ServiceCredentials credentials) {
            }

            @Override
            public ServiceCredentials getCredentials() {
                //TODO
                // Implement custom logic to obtain credentials.

                // Return long-lived credentials: access_key_id and access_key_secret.
                return new DefaultCredentials(accessKeyId, accessKeySecret);

                // Return temporary credentials: access_key_id, access_key_secret, and token.
                // For temporary credentials, refresh the credentials based on the expiration time.
                // return new DefaultCredentials(accessKeyId, accessKeySecret, token);
            }
        };
        // Use credentialsProvider for subsequent operations...
    }
}