Conceda acesso temporário e com escopo definido a recursos do ECS entre contas ao assumir funções do RAM.
Casos de uso
Suponha que sua empresa execute um site de e-commerce no ECS. O departamento de TI cuida das operações e manutenção diárias, mas parceiros externos precisam ocasionalmente de acesso para tarefas específicas de manutenção. Em vez de compartilhar credenciais de longo prazo, como uma conta Alibaba Cloud ou um usuário do RAM, utilize funções do RAM para conceder acesso temporário e restrito.
O diagrama a seguir ilustra o acesso entre contas com uma função do RAM:
Conta A: Conta Alibaba Cloud da sua empresa.
Conta B: Conta Alibaba Cloud do seu parceiro externo.
A Conta A cria uma função do RAM e autoriza a Conta B a assumi-la.
A Conta B cria um usuário do RAM e concede a ele permissão para assumir a função.
O usuário do RAM da Conta B assume a função do RAM da Conta A para gerenciar os recursos desta última.
Procedimento
Criar uma função do RAM e conceder permissões na Conta A
1. Criar uma função do RAM
Faça login no console do RAM com a Conta A. Crie uma função do RAM com a entidade confiável definida como uma conta Alibaba Cloud. Em Principal Name, selecione Other Account e insira o UID da Conta B. Consulte Criar uma função do RAM para uma conta Alibaba Cloud.
2. Conceder permissões à função do RAM
Crie uma política que permita visualizar informações de instâncias e fazer login em instâncias do ECS com o Workbench e anexe-a à função do RAM. Consulte Criar uma política personalizada.
Criar um usuário do RAM e conceder permissões na Conta B
1. Criar um usuário do RAM
Faça login no console do RAM com a Conta B. Crie um usuário do RAM e selecione Console Access e Using permanent AccessKey to access. Consulte Criar um usuário do RAM.
2. Conceder permissões ao usuário do RAM
Anexe a política AliyunSTSAssumeRoleAccess ao usuário do RAM da Conta B. Essa política permite que o usuário assuma todas as funções do RAM. Consulte Conceder permissões a um usuário do RAM.
Para restringir o usuário a uma função específica, consulte Posso especificar a função do RAM que um usuário do RAM pode assumir?
Assumir uma função do RAM
Console
Faça login na página de login de usuário do RAM com o usuário do RAM da Conta B.
Passe o mouse sobre a foto de perfil no canto superior direito e clique em Switch Identity.
Na página Switch Role, insira o UID da Conta A e o nome da função do RAM e clique em OK.
-
Verifique as permissões de acesso.
Faça login no console do ECS e confirme se é possível visualizar as informações das instâncias do ECS.
Verificação 1: O usuário do RAM consegue visualizar informações de instâncias do ECS e fazer login nas instâncias com o Workbench.
Verificação 2: Após a Conta A revogar a autorização, o usuário do RAM não consegue mais visualizar as informações das instâncias do ECS da Conta A.
API
Também é possível acessar os recursos da Conta A programaticamente:
Defina uma variável de ambiente do sistema com a AccessKey obtida ao criar o usuário do RAM da Conta B. O método varia conforme o sistema operacional. Consulte Configurar variáveis de ambiente no Linux, macOS e Windows.
Chame a API
AssumeRolecom o usuário do RAM da Conta B. Passe o ARN da função do RAM da Conta A para obter um token STS temporário.Utilize o token STS para chamar as APIs do serviço Alibaba Cloud desejado e acessar os recursos da Conta A.
Código de exemplo em Java
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>ecs20140526</artifactId>
<version>5.4.4</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>sts20150401</artifactId>
<version>1.1.4</version>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>credentials-java</artifactId>
<version>0.3.10</version>
</dependency>
import com.aliyun.ecs20140526.models.DescribeInstancesRequest;
import com.aliyun.ecs20140526.models.DescribeInstancesResponse;
import com.aliyun.sts20150401.Client;
import com.aliyun.sts20150401.models.AssumeRoleRequest;
import com.aliyun.sts20150401.models.AssumeRoleResponse;
import com.aliyun.sts20150401.models.AssumeRoleResponseBody;
import com.aliyun.teaopenapi.models.Config;
import com.aliyun.teautil.models.RuntimeOptions;
import com.google.gson.Gson;
/**
* Assume a RAM role to obtain temporary access credentials, and then use these credentials to access ECS resources.
*/
public class Sample {
public static void main(String[] args) {
// This is for demonstration purposes only. Select a region-specific endpoint based on your actual business needs.
String stsEndpoint = "sts.cn-shanghai.aliyuncs.com";
String ecsEndpoint = "ecs.cn-shanghai.aliyuncs.com";
// Query the information of ECS instances in cn-shanghai.
String regionId = "cn-shanghai";
// The ARN of the RAM role to be assumed.
String ramRoleArn = "acs:ram::14************16:role/cooperativepartnerrole";
// Use the RAM user of Account B to assume the RAM role of Account A and obtain temporary access credentials.
AssumeRoleResponse assumeRoleResponse = playRamRole(stsEndpoint, ramRoleArn);
// Call the API provided by the Alibaba Cloud service to view the cloud resources of Account A.
accessResources(assumeRoleResponse, ecsEndpoint, regionId);
}
/**
* Use temporary access credentials to access cloud resources.
*
* @param assumeRoleResponse The response object that contains the temporary access credentials.
*/
private static void accessResources(AssumeRoleResponse assumeRoleResponse, String ecsEndpoint, String regionId) {
try {
// Extract the temporary access credential information.
AssumeRoleResponseBody.AssumeRoleResponseBodyCredentials assumeRoleResponseBodyCredentials = assumeRoleResponse.body.credentials;
com.aliyun.credentials.models.Config credentialsConfig = new com.aliyun.credentials.models.Config()
.setType("sts") // The credential type.
.setAccessKeyId(assumeRoleResponseBodyCredentials.accessKeyId)
.setAccessKeySecret(assumeRoleResponseBodyCredentials.accessKeySecret)
.setSecurityToken(assumeRoleResponseBodyCredentials.securityToken);
com.aliyun.credentials.Client credentialClient = new com.aliyun.credentials.Client(credentialsConfig);
// Create an ECS client.
Config ecsConfig = new Config()
.setEndpoint(ecsEndpoint)
.setCredential(credentialClient);
com.aliyun.ecs20140526.Client ecsClient = new com.aliyun.ecs20140526.Client(ecsConfig);
DescribeInstancesRequest describeInstancesRequest = new DescribeInstancesRequest()
.setRegionId(regionId);
RuntimeOptions runtimeOptions = new RuntimeOptions();
// Call the DescribeInstances API and get the response.
DescribeInstancesResponse response = ecsClient.describeInstancesWithOptions(describeInstancesRequest, runtimeOptions);
// Print the response.
System.out.println(new Gson().toJson(response.body));
} catch (Exception e) {
throw new RuntimeException("AccessResources failed: " + e.getMessage());
}
}
/**
* Assume a RAM role to obtain temporary access credentials.
*
* @return The response object that contains the temporary access credentials.
*/
private static AssumeRoleResponse playRamRole(String stsEndpoint, String ramRoleArn) {
try {
// Create an StsClient object and call the assumeRole operation to obtain an STS token.
Config config = new Config()
// System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID") gets the value of AccessKey ID from the environment variable.
.setAccessKeyId(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"))
// System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET") gets the value of AccessKey secret from the environment variable.
.setAccessKeySecret(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"));
config.endpoint = stsEndpoint;
Client client = new Client(config);
// Create an AssumeRoleRequest object and specify the ARN of the RAM role to be assumed and the role session name.
AssumeRoleRequest assumeRoleRequest = new AssumeRoleRequest()
.setRoleArn(ramRoleArn)
.setRoleSessionName("CooperativePartner");
RuntimeOptions runtime = new RuntimeOptions();
return client.assumeRoleWithOptions(assumeRoleRequest, runtime);
} catch (Exception e) {
throw new RuntimeException("play RAM role failed: " + e.getMessage());
}
}
}
Resultado: O programa retorna uma lista de recursos do ECS pertencentes à Conta A na região China (Shanghai).
{
"instances":{
"instance":[
{
"creationTime":"2024-10-23T09:12Z",
"expiredTime":"2099-12-31T15:59Z",
"hostName":"iZ********************pZ",
"imageId":"m-uf****************jf",
"instanceChargeType":"PostPaid",
"instanceId":"i-uf****************ap",
"instanceName":"launch-advisor-20241023-c6",
"instanceNetworkType":"vpc",
"instanceType":"ecs.c6.xlarge",
...
// Some parameters are omitted.
...
"vpcAttributes":{
"natIpAddress":"",
"privateIpAddress":{
"ipAddress":[
"17*.**.**.*15"
]
},
"vSwitchId":"vsw-uf*****************tk",
"vpcId":"vpc-uf*****************kr"
},
"zoneId":"cn-shanghai-b"
}
]
},
"nextToken":"",
"pageNumber":1,
"pageSize":10,
"requestId":"C1468F7E********************7A3A712",
"totalCount":1
}
Referências
O RAM gerencia identidades de usuários e permissões de acesso a recursos. Consulte O que é o RAM.
Consulte Assumir uma função do RAM.
Consulte SSO baseado em função.