how to select and configure access credentials for tablestore - Tablestore: Central de Documentação do Alibaba Cloud

Os requisitos de segurança, validade e rotação de credenciais variam conforme o ambiente de implantação. Escolha um método de configuração adequado ao seu caso de uso para equilibrar segurança e custos de manutenção.

Escolher um tipo de credencial

O Tablestore oferece suporte a vários tipos de credenciais, incluindo pares de AccessKey e tokens STS. Cada método destina-se a um cenário específico de implantação e disponibilidade de SDK.

Método de credencial	Caso de uso	Requer par de AccessKey ou token STS pré-configurado	Credencial subjacente	Validade	Método de rotação ou atualização	Suporte a SDK
Usar um par de AccessKey de usuário RAM	Aplicações em ambientes seguros e estáveis, com baixo risco de ataques externos, que não exigem rotação frequente de credenciais para acesso de longo prazo aos serviços de nuvem.	Sim	Par de AccessKey	Longo prazo	Rotação manual	Java, Go, Python, Node.js, .NET, PHP
Usar credenciais temporárias STS	Aplicações em ambientes não confiáveis que exigem controle sobre a validade do acesso e as permissões.	Sim	Token STS	Temporária	Atualização manual	Java, Go, Python, Node.js, PHP
Usar RAMRoleARN	Aplicações que necessitam de autorização entre contas para acessar serviços de nuvem.	Sim	Token STS	Temporária	Atualização automática	Java
Usar ECSRAMRole	Aplicações executadas em instâncias do Elastic Compute Service (ECS), instâncias do Elastic Container Instance (ECI) ou nós de trabalho do Container Service for Kubernetes (ACK).	Não	Token STS	Temporária	Atualização automática	Java
Usar OIDCRoleARN	Aplicações não confiáveis executadas em nós de trabalho do ACK.	Não	Token STS	Temporária	Atualização automática	Java
Usar credenciais do contexto do Function Compute	Aplicações executadas no Function Compute.	Não	Token STS	Temporária	Nenhuma atualização necessária	Java, Python
Usar CredentialsURI	Aplicações que precisam obter credenciais de um sistema externo.	Não	Token STS	Temporária	Atualização automática	Java
Usar par de AccessKey com rotação automática	Aplicações em ambientes com risco de vazamento de pares de AccessKey que exigem rotação frequente de credenciais para acesso de longo prazo aos serviços de nuvem.	Não	Par de AccessKey	Longo prazo	Rotação automática	Java
Usar credenciais personalizadas	Recuperação personalizada de credenciais quando nenhum dos métodos anteriores atende aos requisitos.	Personalizada	Personalizada	Personalizada	Personalizada	Java
Usar chave de API	Integração de aplicações de IA com Knowledge Store e Memory Store, sem necessidade de gerenciar pares de AccessKey.	Não	Chave de API	Configurável	Revogação e recriação manuais	Python, TypeScript

Configurar credenciais

Após escolher o tipo de credencial, consulte a seção correspondente para obter instruções passo a passo e exemplos de código.

Usar par de AccessKey de usuário RAM

Configure as credenciais com o par de AccessKey (AccessKey ID e AccessKey Secret) de um usuário RAM. Este método exige manutenção manual do par de AccessKey e apresenta maior risco de segurança.

Importante

Uma conta Alibaba Cloud tem permissões totais sobre todos os recursos. Se o par de AccessKey dessa conta vazar, todos os recursos estarão em risco. Utilize o par de AccessKey de um usuário RAM com as permissões mínimas necessárias. Para obter o par de AccessKey de um usuário RAM, consulte Acessar o Tablestore com o par de AccessKey de um usuário RAM.

Configure o par de AccessKey usando variáveis de ambiente ou credenciais estáticas.

Variáveis de ambiente

Configure as variáveis de ambiente. Após defini-las, reinicie sua IDE, CLI, aplicativos de desktop e serviços em segundo plano para carregar as variáveis atualizadas.

Linux

Anexe as variáveis de ambiente ao arquivo ~/.bashrc.

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

Aplique as alterações.
```
source ~/.bashrc
```

Verifique as variáveis de ambiente.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

macOS

Verifique o tipo de shell padrão.
```
echo $SHELL
```

Prossiga conforme o tipo de shell padrão.

Zsh

Anexe as variáveis de ambiente ao arquivo ~/.zshrc.

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

Aplique as alterações.
```
source ~/.zshrc
```

Verifique as variáveis de ambiente.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

Bash

Anexe as variáveis de ambiente ao arquivo ~/.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 as alterações.
```
source ~/.bash_profile
```

Verifique as variáveis de ambiente.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET

Windows

CMD

Defina as variáveis de ambiente no CMD.

setx TABLESTORE_ACCESS_KEY_ID "YOUR_ACCESS_KEY_ID"
setx TABLESTORE_ACCESS_KEY_SECRET "YOUR_ACCESS_KEY_SECRET"

Reinicie o CMD e execute os comandos a seguir para verificar se as variáveis de ambiente foram definidas.
```
echo %TABLESTORE_ACCESS_KEY_ID%
echo %TABLESTORE_ACCESS_KEY_SECRET%
```

PowerShell

Defina as variáveis de ambiente no 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)

Verifique as variáveis de ambiente.

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

Forneça as informações de credenciais por meio de variáveis de ambiente.

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

Credenciais estáticas

Referencie credenciais a partir de variáveis no código. Essas variáveis são preenchidas com valores reais provenientes de variáveis de ambiente, arquivos de configuração ou outras fontes de dados externas durante a execução.

O exemplo a seguir utiliza credenciais estáticas de um arquivo de configuração.

Crie um arquivo de configuração chamado config.ini.

[configName]
TABLESTORE_ACCESS_KEY_ID = your_access_key_id
TABLESTORE_ACCESS_KEY_SECRET = your_access_key_secret

Forneça as informações de credenciais do arquivo de configuração.

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 credenciais temporárias STS

Configure as credenciais com as credenciais de identidade temporárias (AccessKey ID, AccessKey Secret e Security Token) obtidas do Security Token Service (STS). Este método requer manutenção manual do token STS e apresenta maior risco de segurança. Para acessar o Tablestore várias vezes com credenciais temporárias, atualize manualmente o token STS. Para obter credenciais temporárias STS, consulte Usar credenciais temporárias STS para acessar o Tablestore.

Configure as credenciais temporárias STS usando variáveis de ambiente ou credenciais estáticas.

Variáveis de ambiente

Configure as variáveis de ambiente. Após defini-las, reinicie sua IDE, CLI, aplicativos de desktop e serviços em segundo plano para carregar as variáveis atualizadas.

Linux

Anexe as variáveis de ambiente ao arquivo ~/.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 as alterações.
```
source ~/.bashrc
```

Verifique as variáveis de ambiente.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

macOS

Verifique o tipo de shell padrão.
```
echo $SHELL
```

Prossiga conforme o tipo de shell padrão.

Zsh

Anexe as variáveis de ambiente ao arquivo ~/.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 as alterações.
```
source ~/.zshrc
```

Verifique as variáveis de ambiente.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

Bash

Anexe as variáveis de ambiente ao arquivo ~/.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 as alterações.
```
source ~/.bash_profile
```

Verifique as variáveis de ambiente.

echo $TABLESTORE_ACCESS_KEY_ID
echo $TABLESTORE_ACCESS_KEY_SECRET
echo $TABLESTORE_SESSION_TOKEN

Windows

CMD

Defina as variáveis de ambiente no 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 o CMD e execute os comandos a seguir para verificar se as variáveis de ambiente foram definidas.
```
echo %TABLESTORE_ACCESS_KEY_ID%
echo %TABLESTORE_ACCESS_KEY_SECRET%
echo %TABLESTORE_SESSION_TOKEN%
```

PowerShell

Defina as variáveis de ambiente no 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)

Verifique as variáveis de ambiente.

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

Forneça as informações de credenciais por meio de variáveis de ambiente.

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

Credenciais estáticas

O exemplo a seguir utiliza credenciais estáticas de um arquivo de configuração.

Crie um arquivo de configuração chamado 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

Forneça as informações de credenciais do arquivo de configuração.

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 as credenciais com RAMRoleARN. Este método utiliza tokens STS como credencial subjacente. Ao especificar o Alibaba Cloud Resource Name (ARN) de uma função RAM, a ferramenta Credentials solicita um token STS ao serviço STS e o atualiza automaticamente antes da expiração da sessão. Também é possível atribuir um valor a policy para restringir a função RAM a um conjunto menor de permissões. Este método requer um par de AccessKey, o que aumenta o risco de segurança e o esforço de manutenção. Para obter um par de AccessKey, consulte Criar um AccessKey. Para obter um RAMRoleARN, consulte Criar uma função RAM.

Adicione a dependência de credenciais.

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

Configure o par de AccessKey e o RAMRoleARN como credenciais de acesso.

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 as credenciais com ECSRAMRole. Este método utiliza tokens STS como credencial subjacente. O ECSRAMRole permite anexar uma função a uma instância ECS, uma instância ECI ou um nó de trabalho do ACK. O token STS é atualizado automaticamente na instância. Este método dispensa o uso de par de AccessKey ou token STS, eliminando riscos associados à manutenção manual de credenciais. Para obter um ECSRAMRole, consulte Criar uma função RAM.

Adicione a dependência de credenciais.

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

Configure o ECSRAMRole como credencial de acesso.

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

Após configurar uma função RAM para um nó de trabalho do ACK, as aplicações nos pods desse nó podem obter o token STS da função associada diretamente do servidor de metadados, assim como ocorre em instâncias ECS. No entanto, se houver aplicações não confiáveis no cluster, como código enviado por clientes, não obtenha o token STS do servidor de metadados.

O RRSA (RAM Roles for Service Account) fornece isolamento de permissões no nível da aplicação. Ele permite que aplicações não confiáveis obtenham com segurança as credenciais necessárias sem expor outros recursos de nuvem. Este método utiliza tokens STS como credencial subjacente. O cluster ACK cria e monta arquivos de token OIDC para diferentes pods de aplicação e injeta as configurações relacionadas em variáveis de ambiente. A ferramenta Credentials lê essas informações das variáveis de ambiente e chama a operação AssumeRoleWithOIDC do STS para obter o token da função vinculada. Este método dispensa o uso de par de AccessKey ou token STS, eliminando riscos associados à manutenção manual de credenciais. Para mais informações, consulte Usar RRSA para controle de acesso no nível de pod.

Adicione a dependência de credenciais.

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

Configure a função RAM OIDC como credencial de acesso.

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 credenciais do contexto do Function Compute

Configure as credenciais a partir do contexto do Function Compute. Este método utiliza tokens STS como credencial subjacente. O Function Compute assume a função de serviço configurada para obter um token STS, transmitido ao código da função por meio do parâmetro de contexto Credentials. O token vale por 36 horas e não pode ser alterado. Como o tempo máximo de execução de uma função é de 24 horas, o token não expira durante a execução e não precisa de atualização. Este método dispensa o uso de par de AccessKey ou token STS, eliminando riscos associados à manutenção manual de credenciais. Para conceder ao Function Compute as permissões de acesso ao Tablestore, consulte Usar uma função de função para acessar outros serviços de nuvem.

Java

Adicione a dependência de contexto do 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>

Inicialize um provedor de credenciais com as credenciais do contexto do 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

Obtenha credenciais de acesso temporárias do contexto do 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'

Usar CredentialsURI

Configure as credenciais com um CredentialsURI. Este método utiliza tokens STS como credencial subjacente. A ferramenta Credentials obtém um token STS da URI fornecida e inicializa o cliente de credenciais. Este método dispensa o uso de par de AccessKey ou token STS, eliminando riscos associados à manutenção manual de credenciais. O serviço de back-end que responde ao CredentialsURI deve implementar lógica de atualização automática de token STS para garantir que a aplicação sempre obtenha credenciais válidas.

Para permitir que a ferramenta Credentials analise e utilize o token STS, a URI deve obedecer ao seguinte protocolo de resposta:
- Código de status da resposta: 200
- Estrutura do corpo da resposta:
```
{
    "Code": "Success",
    "AccessKeySecret": "AccessKeySecret",
    "AccessKeyId": "AccessKeyId",
    "Expiration": "2021-09-26T03:46:38Z",
    "SecurityToken": "SecurityToken"
}
```

Adicione a dependência de credenciais.

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

Configure o CredentialsURI como credencial de acesso.

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

Usar par de AccessKey com rotação automática

Configure as credenciais com uma ClientKey. Com uma ClientKey, o Key Management Service (KMS) rotaciona automaticamente o par de AccessKey do usuário RAM gerenciado periodicamente, convertendo um par estático em dinâmico e reduzindo o risco de vazamentos. O KMS também suporta rotação imediata, permitindo substituir rapidamente o par de AccessKey em caso de vazamento. Este método dispensa a manutenção manual do par de AccessKey, reduzindo riscos de segurança e esforço operacional.

Adicione a dependência do cliente de segredos.

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

Crie um arquivo de configuração chamado 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>"}]

Forneça as informações de credenciais do arquivo de configuração.

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

Usar credenciais personalizadas

Se nenhum dos métodos anteriores atender aos seus requisitos, implemente a interface Credential Providers para personalizar o fornecimento de credenciais. Caso a implementação subjacente utilize tokens STS, ofereça suporte à atualização de credenciais.

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