Assign a RAM role to an ECI pod - Elastic Container Instance: Central de Documentação do Alibaba Cloud

Uma função do RAM é uma identidade virtual com permissões específicas que um pod ECI pode assumir para herdar tais permissões. Atribuir uma função permite que os aplicativos no pod usem credenciais do Security Token Service (STS) para acessar outros serviços da Alibaba Cloud.

Contexto

Aplicativos implantados em pods ECI frequentemente usam um par de AccessKey de uma conta Alibaba Cloud ou de um usuário RAM para acessar outros serviços, como Object Storage Service (OSS), Virtual Private Cloud (VPC) e ApsaraDB RDS. Alguns usuários incorporam o par de AccessKey diretamente no pod por conveniência, por exemplo, ao defini-lo rigidamente em um arquivo de configuração. Essa prática gera riscos de segurança, incluindo vazamento de credenciais, permissões excessivas e dificuldades na rotação e manutenção de chaves.

O uso de uma função RAM de instância elimina a necessidade de armazenar um par de AccessKey nos pods ECI. Modifique as políticas de permissão anexadas à função RAM atribuída para alterar a permissão de um pod ECI a qualquer momento. Esse método é mais seguro e prático. Para obter mais informações sobre funções do RAM, consulte Visão geral das funções do RAM.

Crie uma função do RAM e conceder permissões

Crie uma função do RAM. Para obter instruções detalhadas, consulte Criar uma função do RAM para um serviço confiável da Alibaba Cloud.

Ao criar a função do RAM, selecione Alibaba Cloud Service como tipo de entidade confiável e Elastic Compute Service como serviço confiável.
Conceda permissões à função do RAM.
1. Crie uma política de permissão. Para obter instruções detalhadas, consulte Criar uma política personalizada.
2. Anexe a política de permissão à função do RAM. Para obter instruções detalhadas, consulte Conceder permissões a uma função do RAM.
(Opcional) Autorize um usuário RAM a usar a função do RAM.

Para permitir que um usuário RAM atribua a função do RAM, conceda a permissão ram:passRole a esse usuário. A política a seguir mostra um exemplo em que ECIRamRoleTest é o nome da função do RAM que o usuário tem permissão para transmitir.
```
{
   "Statement": [
    {
      "Effect": "Allow",
      "Action": "ram:PassRole",
      "Resource": "acs:ram:*:*:role/ECIRamRoleTest" 
    }
  ],
  "Version": "1"
}                
```

Atribuir função do RAM ao pod ECI

Ao criar um pod ECI, use a anotação k8s.aliyun.com/eci-ram-role-name para atribuir uma função do RAM. Isso permite que o pod acesse outros serviços da Alibaba Cloud.

Importante

Adicione as anotações aos metadados no arquivo de configuração do pod. Por exemplo, ao criar um Deployment, adicione as anotações na seção spec.template.metadata.
As anotações relacionadas ao Elastic Container Instance são aplicadas apenas durante a criação do pod. Adicionar ou modificar essas anotações em um pod existente não surte efeito.

O arquivo YAML a seguir fornece um exemplo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
  labels:
    app: test
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test
  template:
    metadata:
      name: test
      labels:
        app: test
        alibabacloud.com/eci: "true" 
      annotations:
        k8s.aliyun.com/eci-ram-role-name : "${your_ram_role_name}"   # Assign the RAM role.
    spec:
      containers:
      - name: test
        image: registry.cn-shanghai.aliyuncs.com/eci_open/centos:7
        command: ["sleep"]
        args: ["3600"]

Obter um token STS

Acesse uma URL de metadados de uma instância ECI para recuperar um token STS referente à função do RAM atribuída. Use esse token para acessar recursos conforme as permissões da função. O token STS é atualizado automática e periodicamente.

curl http://100.100.100.200/latest/meta-data/ram/security-credentials/${your_ram_role_name}

Substitua ${your_ram_role_name} pelo nome da sua função do RAM. Por exemplo, se o nome da função for ECIRamRoleTest, execute o seguinte comando:

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

A resposta contém o token STS. A saída a seguir fornece um exemplo:

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

Acessar serviços de nuvem com um token STS

O exemplo a seguir demonstra como usar o sdk Go e um token STS para acessar o Object Storage Service (OSS). Neste cenário, o código acessa um bucket OSS especificado e lista todos os objetos nele contidos.

Nota

Este exemplo serve apenas para fins de demonstração. Em ambiente de produção, desenvolva seu código com base nos requisitos específicos do seu negócio. Para mais detalhes, consulte a documentação do sdk referente ao serviço da Alibaba Cloud que você deseja acessar.

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", "Please input oss endpoint, Recommended internal endpoint, eg: oss-cn-hangzhou-internal.aliyuncs.com")
	flag.StringVar(&ossBucketName, "bucket", "", "Please input 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("Please input oss endpoint, eg: oss-cn-hangzhou-internal.aliyuncs.com")
	}
	if ossBucketName == "" {
		log.Fatal("Please provide an OSS bucket name.")
	}

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

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

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

	// Create an OSS client. In a production environment, you must periodically update the client to prevent access failures due to an expired STS token.
	ossClient, err := oss.New(ossEndpoint, authServiceIdentity.AccessKeyId,
		authServiceIdentity.AccessKeySecret, oss.SecurityToken(authServiceIdentity.SecurityToken))
	if err != nil {
		log.Fatalf("Failed to create an OSS client: %s", err)
	}

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

	// List objects in the bucket.
	marker := ""
	for {
		lsRes, err := bucket.ListObjects(oss.Marker(marker))
		if err != nil {
			log.Fatalf("Failed to list objects from bucket %q: %s", ossBucketName, err)
		}
		// Print the listed objects. By default, a maximum of 100 objects are returned at a time.
		for _, object := range lsRes.Objects {
			log.Println("Object: ", object.Key)
		}
		if lsRes.IsTruncated {
			marker = lsRes.NextMarker
		} else {
			break
		}
	}
}