how to select and configure access credentials for tablestore - Tablestore

Los requisitos de seguridad, validez y rotación de credenciales varían según el entorno de despliegue. Elija un método de configuración de credenciales adecuado para su caso de uso con el fin de equilibrar la seguridad y los costos de mantenimiento.

Elegir un tipo de credencial

Tablestore admite varios tipos de credenciales, incluidos pares de AccessKey y tokens de STS. Cada método está diseñado para un escenario de despliegue específico y una disponibilidad determinada del SDK.

Método de credencial	Caso de uso	Requiere un par de AccessKey o token de STS preconfigurado	Credencial subyacente	Validez	Método de rotación o actualización	Compatibilidad con SDK
Use an AccessKey pair of a RAM user	Aplicaciones que se ejecutan en entornos seguros y estables, con bajo riesgo de ataques externos y que no requieren rotación frecuente de credenciales para el acceso a largo plazo a servicios en la nube.	Sí	Par de AccessKey	Largo plazo	Rotación manual	Java, Go, Python, Node.js, .NET, PHP
Use STS temporary credentials	Aplicaciones que se ejecutan en entornos no confiables y requieren control sobre la validez del acceso y los permisos.	Sí	Token de STS	Temporal	Actualización manual	Java, Go, Python, Node.js, PHP
Use RAMRoleARN	Aplicaciones que requieren autorización entre cuentas para acceder a servicios en la nube.	Sí	Token de STS	Temporal	Actualización automática	Java
Use ECSRAMRole	Aplicaciones que se ejecutan en instancias de Elastic Compute Service (ECS), instancias de Elastic Container Instance (ECI) o nodos worker de Container Service for Kubernetes (ACK).	No	Token de STS	Temporal	Actualización automática	Java
Use OIDCRoleARN	Aplicaciones no confiables que se ejecutan en nodos worker de ACK.	No	Token de STS	Temporal	Actualización automática	Java
Use credentials from the Function Compute context	Aplicaciones que se ejecutan en Function Compute.	No	Token de STS	Temporal	No requiere actualización	Java, Python
Use CredentialsURI	Aplicaciones que necesitan obtener credenciales de un sistema externo.	No	Token de STS	Temporal	Actualización automática	Java
Use an automatically rotated AccessKey pair	Aplicaciones que se ejecutan en entornos con riesgo de fuga de pares de AccessKey y requieren rotación frecuente de credenciales para el acceso a largo plazo a servicios en la nube.	No	Par de AccessKey	Largo plazo	Rotación automática	Java
Use custom credentials	Recuperación personalizada de credenciales para casos en los que ninguno de los métodos anteriores cumple con sus requisitos.	Personalizado	Personalizado	Personalizado	Personalizado	Java
Use an API key	Integración de aplicaciones de IA con Knowledge Store y Memory Store, sin necesidad de gestionar pares de AccessKey.	No	Clave de API	Configurable	Revocación y recreación manuales	Python, TypeScript

Configurar credenciales

Una vez que haya elegido un tipo de credencial, consulte la sección correspondiente para obtener instrucciones paso a paso y ejemplos de código.

Usar un par de AccessKey de un usuario de RAM

Configure las credenciales con el par de AccessKey (AccessKey ID y AccessKey Secret) de un usuario de RAM. Este método requiere mantenimiento manual del par de AccessKey y presenta un mayor riesgo de seguridad.

Importante

Una cuenta de Alibaba Cloud tiene permisos completos sobre todos los recursos. Si se filtra el par de AccessKey de una cuenta de Alibaba Cloud, todos los recursos de dicha cuenta quedan en riesgo. Utilice el par de AccessKey de un usuario de RAM con los permisos mínimos necesarios. Para obtener el par de AccessKey de un usuario de RAM, consulte Access Tablestore with a RAM user's AccessKey pair.

Configure el par de AccessKey mediante variables de entorno o credenciales estáticas.

Variables de entorno

Configure las variables de entorno. Después de establecerlas, reinicie su IDE, CLI, aplicaciones de escritorio y servicios en segundo plano para cargar las variables de entorno actualizadas.

Linux

Agregue las variables de entorno al archivo ~/.bashrc.

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

Aplique los cambios.
```
source ~/.bashrc
```

Compruebe las variables de entorno.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

macOS

Verifique el tipo de shell predeterminado.
```
echo $SHELL
```

Continúe según el tipo de shell predeterminado.

Zsh

Agregue las variables de entorno al archivo ~/.zshrc.

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

Aplique los cambios.
```
source ~/.zshrc
```

Compruebe las variables de entorno.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

Bash

Agregue las variables de entorno al archivo ~/.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

Aplique los cambios.
```
source ~/.bash_profile
```

Compruebe las variables de entorno.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

Windows

CMD

Establezca las variables de entorno en CMD.

setx TABLESTORE_ACCESS_KEY_ID "YOUR_ACCESS_KEY_ID"
setx TABLESTORE_ACCESS_KEY_SECRET "YOUR_ACCESS_KEY_SECRET"

Reinicie CMD y ejecute los siguientes comandos para comprobar que las variables de entorno se han establecido correctamente.
```
echo %TABLESTORE_ACCESS_KEY_ID%
echo %TABLESTORE_ACCESS_KEY_SECRET%
```

PowerShell

Establezca las variables de entorno en 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)

Compruebe las variables de entorno.

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

Pase la información de credenciales mediante variables de entorno.

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");

Credenciales estáticas

Haga referencia a las credenciales desde variables en su código. Estas variables se rellenan con valores reales de credenciales provenientes de variables de entorno, archivos de configuración u otras fuentes de datos externas durante la ejecución.

El siguiente ejemplo utiliza credenciales estáticas desde un archivo de configuración.

Cree un archivo de configuración llamado config.ini.

[configName]
TABLESTORE_ACCESS_KEY_ID = your_access_key_id
TABLESTORE_ACCESS_KEY_SECRET = your_access_key_secret

Pase la información de credenciales desde el archivo de configuración.

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;
}

Usar credenciales temporales de STS

Configure las credenciales con las credenciales de identidad temporal (AccessKey ID, AccessKey Secret y Security Token) obtenidas de Security Token Service (STS). Este método requiere mantenimiento manual del token de STS y presenta un mayor riesgo de seguridad. Para acceder a Tablestore varias veces con credenciales temporales, debe actualizar manualmente el token de STS. Para obtener credenciales temporales de STS, consulte Use STS temporary credentials to access Tablestore.

Configure las credenciales temporales de STS mediante variables de entorno o credenciales estáticas.

Variables de entorno

Configure las variables de entorno. Después de establecerlas, reinicie su IDE, CLI, aplicaciones de escritorio y servicios en segundo plano para cargar las variables de entorno actualizadas.

Linux

Agregue las variables de entorno al archivo ~/.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

Aplique los cambios.
```
source ~/.bashrc
```

Compruebe las variables de entorno.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

macOS

Verifique el tipo de shell predeterminado.
```
echo $SHELL
```

Continúe según el tipo de shell predeterminado.

Zsh

Agregue las variables de entorno al archivo ~/.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

Aplique los cambios.
```
source ~/.zshrc
```

Compruebe las variables de entorno.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

Bash

Agregue las variables de entorno al archivo ~/.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

Aplique los cambios.
```
source ~/.bash_profile
```

Compruebe las variables de entorno.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

Windows

CMD

Establezca las variables de entorno en 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"

Reinicie CMD y ejecute los siguientes comandos para comprobar que las variables de entorno se han establecido correctamente.
```
echo %TABLESTORE_ACCESS_KEY_ID%
echo %TABLESTORE_ACCESS_KEY_SECRET%
echo %TABLESTORE_SESSION_TOKEN%
```

PowerShell

Establezca las variables de entorno en 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)

Compruebe las variables de entorno.

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

Pase la información de credenciales mediante variables de entorno.

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');

Credenciales estáticas

El siguiente ejemplo utiliza credenciales estáticas desde un archivo de configuración.

Cree un archivo de configuración llamado 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

Pase la información de credenciales desde el archivo de configuración.

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;
}

Usar RAMRoleARN

Configure las credenciales con RAMRoleARN. Este método utiliza tokens de STS como credencial subyacente. Cuando especifica el Alibaba Cloud Resource Name (ARN) de un rol de RAM, la herramienta Credentials solicita un token de STS al servicio STS y actualiza automáticamente el token antes de que expire la sesión. También puede asignar un valor a policy para restringir el rol de RAM a un conjunto menor de permisos. Este método requiere un par de AccessKey, lo que aumenta el riesgo de seguridad y el esfuerzo de mantenimiento. Para obtener un par de AccessKey, consulte Create an AccessKey. Para obtener un RAMRoleARN, consulte Create a RAM role.

Agregue la dependencia de credenciales.

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

Configure el par de AccessKey y RAMRoleARN como credenciales de acceso.

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...
    }
}

Usar ECSRAMRole

Configure las credenciales con ECSRAMRole. Este método utiliza tokens de STS como credencial subyacente. ECSRAMRole le permite adjuntar un rol a una instancia de ECS, una instancia de ECI o un nodo worker de ACK. El token de STS se actualiza automáticamente dentro de la instancia. Este método no requiere un par de AccessKey ni un token de STS, lo que elimina el riesgo asociado al mantenimiento manual de credenciales. Para obtener un ECSRAMRole, consulte Create a RAM role.

Agregue la dependencia de credenciales.

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

Configure ECSRAMRole como credenciales de acceso.

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...
    }
}

Usar OIDCRoleARN

Después de configurar un rol de RAM para un nodo worker de ACK, las aplicaciones en pods de ese nodo pueden obtener el token de STS del rol asociado desde el servidor de metadatos, de forma similar a las aplicaciones desplegadas en instancias de ECS. Sin embargo, si se ejecutan aplicaciones no confiables en el clúster, como código enviado por clientes, no obtenga el token de STS del servidor de metadatos.

RAM Roles for Service Account (RRSA) proporciona aislamiento de permisos a nivel de aplicación. RRSA permite que las aplicaciones no confiables obtengan de forma segura las credenciales necesarias sin exponer otros recursos en la nube. Este método utiliza tokens de STS como credencial subyacente. El clúster de ACK crea y monta archivos de token OIDC para diferentes pods de aplicaciones e inyecta la información de configuración relacionada en variables de entorno. La herramienta Credentials lee la información de configuración de las variables de entorno y llama a la operación AssumeRoleWithOIDC de STS para obtener el token de STS del rol vinculado. Este método no requiere un par de AccessKey ni un token de STS, lo que elimina el riesgo asociado al mantenimiento manual de credenciales. Para más información, consulte Use RRSA for pod-level access control.

Agregue la dependencia de credenciales.

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

Configure el rol de RAM OIDC como credenciales de acceso.

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...
    }
}

Usar credenciales del contexto de Function Compute

Configure las credenciales desde el contexto de Function Compute. Este método utiliza tokens de STS como credencial subyacente. Function Compute asume el rol de servicio configurado para la función con el fin de obtener un token de STS, el cual se pasa al código de la función mediante el parámetro de contexto Credentials. El token tiene una validez de 36 horas y no se puede modificar. Dado que el tiempo máximo de ejecución de una función es de 24 horas, el token no caduca durante la ejecución y no requiere actualización. Este método no necesita un par de AccessKey ni un token de STS, lo que elimina el riesgo asociado al mantenimiento manual de credenciales. Para otorgar a Function Compute los permisos necesarios para acceder a Tablestore, consulte Use a function role to access other cloud services.

Java

Agregue la dependencia del contexto de 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>

Inicialice un proveedor de credenciales con las credenciales del contexto de 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

Obtenga credenciales de acceso temporales del contexto de 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'

Uso de CredentialsURI

Configure las credenciales mediante un CredentialsURI. Este método utiliza tokens STS como credencial subyacente. La herramienta Credentials obtiene un token STS desde la URI que usted proporcione e inicializa el cliente de credenciales. Este enfoque no requiere un par de AccessKey ni un token STS, lo cual elimina el riesgo asociado al mantenimiento manual de credenciales. El servicio de backend que responda al CredentialsURI debe implementar una lógica de renovación automática de tokens STS para garantizar que la aplicación siempre pueda obtener credenciales válidas.

Para permitir que la herramienta Credentials analice sintácticamente y utilice el token STS, la URI debe cumplir con el siguiente protocolo de respuesta:
- Código de estado de la respuesta: 200
- Estructura del cuerpo de la respuesta:
```
{
    "Code": "Success",
    "AccessKeySecret": "AccessKeySecret",
    "AccessKeyId": "AccessKeyId",
    "Expiration": "2021-09-26T03:46:38Z",
    "SecurityToken": "SecurityToken"
}
```

Agregue la dependencia de credenciales.

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

Configure CredentialsURI como las credenciales de acceso.

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...
    }
}

Uso de un par de AccessKey con rotación automática

Configure las credenciales mediante un ClientKey. Con un ClientKey, Key Management Service (KMS) rota automáticamente el par de AccessKey del usuario RAM administrado según un programa periódico. Esto convierte un par de AccessKey estático en uno dinámico y reduce el riesgo de filtraciones. KMS también admite la rotación inmediata, lo que le permite reemplazar rápidamente el par de AccessKey si se filtra. Este método no requiere el mantenimiento manual del par de AccessKey, lo que disminuye los riesgos de seguridad y el esfuerzo de administración.

Agregue la dependencia del cliente de secretos.

<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>

Cree un archivo de configuración llamado 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>"}]

Pase la información de las credenciales desde el archivo de configuración.

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...
    }
}

Uso de credenciales personalizadas

Si ninguno de los métodos anteriores de configuración de credenciales satisface sus requisitos, implemente la interfaz Credential Providers para personalizar la forma en que se proporcionan las credenciales. Si la implementación subyacente utiliza tokens STS, debe admitir la renovación de credenciales.

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...
    }
}