Elastic Container Instance:Utiliser un rôle RAM d'instance via les API

Pourquoi utiliser un rôle RAM d'instance

Coder en dur des paires AccessKey dans les fichiers de configuration pose deux problèmes majeurs : risque de fuite des identifiants et nécessité de modifier chaque instance pour mettre à jour les autorisations. Les rôles RAM d'instance résolvent ces deux difficultés :

• Aucun identifiant sur le disque. Les applications récupèrent des jetons STS à durée de vie limitée depuis les métadonnées de l'instance au moment de l'exécution.

• Gestion centralisée des autorisations. Pour modifier les accès de l'instance, mettez simplement à jour le rôle RAM, sans toucher à l'instance elle-même.

• Rotation automatique des jetons. Les jetons STS expirent et sont actualisés automatiquement, ce qui limite l'impact potentiel en cas d'exposition.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Un compte Alibaba Cloud ou un utilisateur RAM disposant des autorisations nécessaires pour appeler CreateRole, CreatePolicy et AttachPolicyToRole dans RAM, ainsi que CreateContainerGroup dans ECI.

• (Facultatif) Si vous utilisez un utilisateur RAM pour créer l'instance de conteneur élastique, cet utilisateur doit également disposer de l'autorisation ram:PassRole sur le rôle cible.

Fonctionnement

1. Créez un rôle RAM d'instance et configurez sa politique de confiance pour autoriser ECS à l'endosser.

2. Créez une politique d'autorisation et attachez-la au rôle.

3. (Facultatif) Accordez à un utilisateur RAM l'autorisation de transmettre le rôle à une instance.

4. Attribuez le rôle à une instance de conteneur élastique via CreateContainerGroup.

5. Récupérez les identifiants STS depuis les métadonnées de l'instance à l'intérieur du pod, puis utilisez-les pour appeler d'autres services Alibaba Cloud.

Étape 1 : Créer un rôle RAM d'instance

Appelez CreateRole avec les paramètres suivants :

• RoleName : Un nom descriptif pour le rôle. Cet exemple utilise ECIRamRoleTest.

• AssumeRolePolicyDocument : La politique de confiance qui accorde à ECS le droit d'endosser ce rôle.

{
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "ecs.aliyuncs.com"
        ]
      }
    }
  ],
  "Version": "1"
}

L'entité de confiance doit être définie sur Elastic Container Instance et le service de confiance doit être Elastic Compute Service (ECS), représenté par le principal ecs.aliyuncs.com.

Étape 2 : Attacher une politique d'autorisation au rôle

2a. Créer une politique personnalisée

Appelez CreatePolicy avec les paramètres suivants :

• PolicyName : ECIRamRoleTestPolicy

• PolicyDocument : Les autorisations à accorder. L'exemple suivant accorde un accès en lecture à tous les compartiments Object Storage Service (OSS) :

{
  "Statement": [
    {
      "Action": [
        "oss:Get*",
        "oss:List*"
      ],
      "Effect": "Allow",
      "Resource": "*"
    }
  ],
  "Version": "1"
}

Respectez le principe du moindre privilège : n'accordez que les autorisations strictement nécessaires à l'application.

2b. Attacher la politique au rôle

Appelez AttachPolicyToRole avec les paramètres suivants :

Étape 3 (facultative) : Autoriser un utilisateur RAM à transmettre le rôle

Ignorez cette étape si vous utilisez un compte Alibaba Cloud pour créer l'instance de conteneur élastique.

Si un utilisateur RAM crée l'instance de conteneur élastique et lui attribue le rôle, cet utilisateur a besoin de l'autorisation ram:PassRole sur ce rôle. Sans elle, l'utilisateur RAM ne peut pas déléguer le rôle à l'instance.

1. Connectez-vous à la console RAM en utilisant un compte Alibaba Cloud ou un utilisateur RAM disposant des droits d'administrateur.

2. Créez une politique personnalisée avec le document suivant, puis attachez-la à l'utilisateur RAM. Pour plus de détails, reportez-vous à la rubrique Accorder des autorisations à un utilisateur RAM.

{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "ram:PassRole",
      "Resource": "acs:ram:*:*:role/ECIRamRoleTest"
    }
  ],
  "Version": "1"
}

Remplacez ECIRamRoleTest par le nom réel du rôle si vous avez utilisé un nom différent à l'étape 1.

Étape 4 : Attribuer le rôle à une instance de conteneur élastique

Lors de l'appel à CreateContainerGroup, définissez le paramètre RamRoleName avec le nom du rôle créé à l'étape 1.

Chaque instance de conteneur élastique ne prend en charge qu'un seul rôle RAM d'instance. Si un rôle est déjà attribué, toute tentative d'attribution d'un autre rôle renvoie une erreur.

Étape 5 : Récupérer et utiliser les identifiants STS

Récupérer le jeton STS

Depuis l'intérieur du pod, interrogez le point de terminaison des métadonnées de l'instance :

curl http://100.100.100.200/latest/meta-data/ram/security-credentials/ECIRamRoleTest

Remplacez ECIRamRoleTest par votre nom de rôle réel. La réponse se présente comme suit :

{
  "AccessKeyId": "STS.******",
  "AccessKeySecret": "******",
  "Expiration": "2023-06-22T19:13:58Z",
  "SecurityToken": "******",
  "LastUpdated": "2023-06-22T13:13:58Z",
  "Code": "Success"
}

Utiliser le jeton STS pour accéder aux services Alibaba Cloud

L'exemple Go ci-dessous récupère les identifiants depuis les métadonnées de l'instance et les utilise pour lister les objets d'un compartiment OSS. Les identifiants sont lus depuis le point de terminaison des métadonnées, aucune paire AccessKey statique n'est intégrée au code.

Cet exemple illustre le modèle de récupération des identifiants. En production, adaptez le code aux besoins de votre application et consultez la documentation du SDK pour le service cible.

package main

import (
	"encoding/json"
	"flag"
	"log"
	"os/exec"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

const (
	securityCredUrl = "http://100.100.100.200/latest/meta-data/ram/security-credentials/"
)

var (
	ossEndpoint   string
	ossBucketName string
)

func init() {
	flag.StringVar(&ossEndpoint, "endpoint", "oss-cn-hangzhou-internal.aliyuncs.com", "OSS endpoint (internal endpoint recommended, e.g. oss-cn-hangzhou-internal.aliyuncs.com)")
	flag.StringVar(&ossBucketName, "bucket", "", "OSS bucket name")
}

type AssumedRoleUserCredentialsWithServiceIdentity struct {
	AccessKeyId     string `json:"AccessKeyId" xml:"AccessKeyId"`
	AccessKeySecret string `json:"AccessKeySecret" xml:"AccessKeySecret"`
	Expiration      string `json:"Expiration" xml:"Expiration"`
	SecurityToken   string `json:"SecurityToken" xml:"SecurityToken"`
	LastUpdated     string `json:"LastUpdated" xml:"LastUpdated"`
	Code            string `json:"Code" xml:"Code"`
}

func main() {
	flag.Parse()

	if ossEndpoint == "" {
		log.Fatal("OSS endpoint is required, e.g. oss-cn-hangzhou-internal.aliyuncs.com")
	}
	if ossBucketName == "" {
		log.Fatal("OSS bucket name is required")
	}

	output, err := exec.Command("curl", securityCredUrl).Output()
	if err != nil {
		log.Fatalf("Failed to get RAM role name from metadata server: %s", err)
	}

	output, err = exec.Command("curl", securityCredUrl+string(output)).Output()
	if err != nil {
		log.Fatalf("Failed to get STS credentials from metadata server: %s", err)
	}

	authServiceIdentity := new(AssumedRoleUserCredentialsWithServiceIdentity)
	if err := json.Unmarshal(output, authServiceIdentity); err != nil {
		log.Fatalf("Failed to parse STS credentials: %s", err)
	}

	// Create an OSS client using STS credentials. In production, refresh the client
	// before the token expires to avoid access failures.
	ossClient, err := oss.New(ossEndpoint, authServiceIdentity.AccessKeyId,
		authServiceIdentity.AccessKeySecret, oss.SecurityToken(authServiceIdentity.SecurityToken))
	if err != nil {
		log.Fatalf("Failed to create OSS client: %s", err)
	}

	// Get the bucket handle.
	bucket, err := ossClient.Bucket(ossBucketName)
	if err != nil {
		log.Fatalf("Failed to get bucket %q: %s", ossBucketName, err)
	}

	// List objects in the bucket. Up to 100 objects are returned per call by default.
	marker := ""
	for {
		lsRes, err := bucket.ListObjects(oss.Marker(marker))
		if err != nil {
			log.Fatalf("Failed to list objects in bucket %q: %s", ossBucketName, err)
		}
		for _, object := range lsRes.Objects {
			log.Println("Object:", object.Key)
		}
		if lsRes.IsTruncated {
			marker = lsRes.NextMarker
		} else {
			break
		}
	}
}

Étapes suivantes

• Pour gérer les rôles RAM et les politiques via la console plutôt que par API, consultez la rubrique Présentation des rôles RAM.

• Pour contrôler quels utilisateurs RAM peuvent créer des instances de conteneur élastique et attribuer des rôles, reportez-vous à la rubrique Accorder des autorisations à un utilisateur RAM.