Accordez un accès temporaire et limité aux ressources ECS entre différents comptes en endossant des rôles RAM.
Cas d'utilisation
Imaginons que votre entreprise héberge un site e-commerce sur ECS. Votre service informatique gère les opérations quotidiennes, mais des partenaires externes ont parfois besoin d'accéder au système pour effectuer des tâches de maintenance spécifiques. Plutôt que de partager des identifiants à long terme, tels qu'un compte Alibaba Cloud ou un utilisateur RAM, utilisez des rôles RAM pour accorder un accès temporaire et ciblé.
Le schéma suivant illustre l'accès intercomptes via un rôle RAM :
Compte A : le compte Alibaba Cloud de votre entreprise.
Compte B : le compte Alibaba Cloud de votre partenaire externe.
Le compte A crée un rôle RAM et autorise le compte B à l'endosser.
Le compte B crée un utilisateur RAM et lui accorde l'autorisation d'endosser ce rôle.
L'utilisateur RAM du compte B endosse le rôle RAM du compte A pour gérer les ressources de ce dernier.
Procédure
Créer un rôle RAM et accorder des autorisations dans le compte A
1. Créer un rôle RAM
Connectez-vous à la console RAM avec le compte A. Créez un rôle RAM en définissant l'entité de confiance sur un compte Alibaba Cloud. Pour Principal Name, sélectionnez Other Account et saisissez l'UID du compte B. Consultez la rubrique Créer un rôle RAM pour un compte Alibaba Cloud.
2. Accorder des autorisations au rôle RAM
Créez une politique qui permet d'afficher les informations des instances et de se connecter aux instances ECS avec Workbench, puis attachez-la au rôle RAM. Consultez la rubrique Créer une politique personnalisée.
Créer un utilisateur RAM et accorder des autorisations dans le compte B
1. Créer un utilisateur RAM
Connectez-vous à la console RAM avec le compte B. Créez un utilisateur RAM et sélectionnez Console Access ainsi que Using permanent AccessKey to access. Consultez la rubrique Créer un utilisateur RAM.
2. Accorder des autorisations à l'utilisateur RAM
Attachez la politique AliyunSTSAssumeRoleAccess à l'utilisateur RAM du compte B. Cette politique permet à l'utilisateur RAM d'endosser tous les rôles RAM. Consultez la rubrique Accorder des autorisations à un utilisateur RAM.
Pour restreindre l'utilisateur à un rôle spécifique, consultez la rubrique Puis-je spécifier le rôle RAM qu'un utilisateur RAM peut endosser ?
Endosser un rôle RAM
Console
Connectez-vous à la page de connexion de l'utilisateur RAM avec l'utilisateur RAM du compte B.
Survolez l'image de profil dans le coin supérieur droit et cliquez sur Switch Identity.
Sur la page Switch Role, saisissez l'UID du compte A et le nom du rôle RAM, puis cliquez sur OK.
-
Vérifiez les autorisations d'accès.
Connectez-vous à la console ECS et vérifiez que vous pouvez afficher les informations des instances ECS.
Vérification 1 : l'utilisateur RAM peut afficher les informations des instances ECS et se connecter aux instances avec Workbench.
Vérification 2 : après la révocation de l'autorisation par le compte A, l'utilisateur RAM ne peut plus afficher les informations des instances ECS du compte A.
API
Vous pouvez également accéder aux ressources du compte A par programmation :
Définissez une variable d'environnement système avec l'AccessKey obtenu lors de la création de l'utilisateur RAM du compte B. La méthode varie selon le système d'exploitation. Consultez la rubrique Configurer des variables d'environnement sous Linux, macOS et Windows.
Appelez l'API
AssumeRoleavec l'utilisateur RAM du compte B. Transmettez l'ARN du rôle RAM du compte A pour obtenir un jeton STS temporaire.Utilisez le jeton STS pour appeler les API du service Alibaba Cloud cible afin d'accéder aux ressources du compte A.
Exemple de code 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());
}
}
}
Résultat : le programme renvoie une liste des ressources ECS appartenant au compte A dans la région Chine (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
}
Références
RAM gère les identités des utilisateurs et les autorisations d'accès aux ressources. Consultez la rubrique Présentation de RAM
Consultez la rubrique Endosser un rôle RAM.
Consultez la rubrique SSO basé sur les rôles.