Use an STS token for mobile access to Alibaba Cloud - Resource Access Management: Central de Documentação do Alibaba Cloud

Um aplicativo móvel pode usar um token STS de uma função do RAM para acessar recursos do Alibaba Cloud com segurança, sem incorporar credenciais de longo prazo.

Informações básicas

Uma empresa desenvolve um aplicativo móvel que utiliza o Object Storage Service (OSS). O aplicativo precisa se conectar diretamente ao OSS para enviar ou baixar dados, mas é executado em dispositivos móveis dos usuários finais, que não são controlados pela empresa.

A empresa tem os seguintes requisitos:

Transferência direta de dados: A empresa deseja que o aplicativo se conecte diretamente ao OSS para uploads e downloads, em vez de rotear os dados pelo servidor de aplicativos backend.
Gerenciamento seguro de credenciais: É necessário evitar a incorporação de credenciais de longo prazo, como uma AccessKey, no aplicativo móvel. Os dispositivos dos usuários finais são ambientes de execução não confiáveis.
Controle de riscos: Para seguir o princípio do menor privilégio, cada aplicativo deve ter permissões mínimas e uma sessão de curta duração ao se conectar ao OSS.

Solução

Quando o aplicativo móvel precisa enviar ou baixar dados do OSS, ele solicita credenciais a um servidor de aplicativos. O servidor de aplicativos, atuando como um usuário do RAM, assume uma função do RAM chamando a operação STS AssumeRole e transmite o token STS retornado ao aplicativo, que o utiliza para acessar o OSS.

移动设备应用访问阿里云

O aplicativo solicita credenciais ao servidor de aplicativos.
Crie uma função do RAM e conceda a ela as permissões necessárias.

Para mais informações, consulte Crie uma função do RAM e conceda permissões .
Crie um usuário do RAM para o servidor de aplicativos e permita que esse usuário assuma a função do RAM.

Para mais informações, consulte Crie um usuário do RAM e permita a assunção de função .
O servidor de aplicativos chama a operação AssumeRole do STS para obter um token STS da função do RAM.

Para mais informações, consulte Obtenha um token STS .
O servidor de aplicativos também pode restringir as permissões do token STS para garantir um controle mais granular sobre cada cliente do aplicativo.

Para mais informações, consulte Limite as permissões do token STS .
Quando o aplicativo precisar enviar ou baixar dados diretamente, utilize o token STS para acessar o OSS.

Para mais informações, consulte Use um token STS para acessar o OSS .

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

Suponha que o ID da sua conta do Alibaba Cloud seja 123456789012****.

Use sua conta do Alibaba Cloud para criar uma função do RAM chamada oss-objectmanager e selecione Cloud Account como o tipo de principal.
Nota
Ao criar a função do RAM, selecione Current Account como o principal confiável. Isso permite que apenas usuários do RAM pertencentes à mesma conta do Alibaba Cloud assumam essa função.

Para mais informações, consulte Create a RAM role for an Alibaba Cloud account.

Após criar a função do RAM, visualize seu ARN e política de confiança na página de detalhes da função.
- O ARN da função do RAM é acs:ram::123456789012****:role/oss-objectmanager.
- A política de confiança da função do RAM é a seguinte.
  
  Nota
  A política de confiança abaixo permite que qualquer principal autenticado na conta do Alibaba Cloud 123456789012**** assuma a função.
```
{
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Effect": "Allow",
      "Principal": {
        "RAM": [
          "acs:ram::123456789012****:root"
        ]
      }
    }
  ],
  "Version": "1"
}
```
Anexe a política de sistema AliyunOSSFullAccess à função do RAM oss-objectmanager.

Para mais informações, consulte Grant permissions to a RAM role.

Crie um usuário do RAM e permita a assunção de função

Crie um usuário do RAM chamado appserver para o servidor de aplicativos.

Para mais informações, consulte Create a RAM user.
Conceda a permissão AliyunSTSAssumeRoleAccess ao usuário do RAM appserver para permitir que ele assuma funções.

Para mais informações, consulte Grant permissions to a RAM user.

Obtenha um token STS

O servidor de aplicativos usa a AccessKey do usuário do RAM para chamar a operação STS AssumeRole.
Nota
- Antes de usar a Alibaba Cloud Command Line Interface (CLI), instale-a no servidor de aplicativos e configure-a com as credenciais do usuário do RAM. Para mais informações, consulte STS CLI reference.
- Neste exemplo, o parâmetro Policy não foi especificado. Portanto, o token STS retornado herda todas as permissões da função do RAM oss-objectmanager. Para restringir ainda mais as permissões do token STS, consulte Limite as permissões do token STS.
O exemplo a seguir mostra como usar a Alibaba Cloud CLI para chamar a operação AssumeRole:
```
aliyun sts AssumeRole --RoleArn 'acs:ram::123456789012****:role/oss-objectmanager' --RoleSessionName 'client-001'
```

O STS retorna um token STS ao servidor de aplicativos. Esse token inclui um AccessKeyId, um AccessKeySecret e um SecurityToken.

O código a seguir apresenta um exemplo de resposta:

{
     "AssumedRoleUser": {
         "AssumedRoleId": "391578752573****:client-001",
         "Arn": "acs:ram::123456789012****:role/oss-objectmanager/client-001"
     }, 
     "Credentials": {
         "AccessKeySecret": "yourAccessKeySecret",
         "SecurityToken": "yourSecurityToken",
         "Expiration": "2016-01-13T15:02:37Z",
         "AccessKeyId": "yourAccessKeyId"
     }, 
     "RequestId": "E1779AAB-E7AF-47D6-A9A4-53128708B6CE"
 }

Nota

O SecurityToken possui um tempo de expiração curto. Caso seja necessária uma sessão mais longa, o servidor de aplicativos deve reemitir o token STS periodicamente, por exemplo, a cada 1800 segundos.

Limite as permissões do token STS

Utilize o parâmetro Policy na chamada AssumeRole para restringir as permissões de um token STS com base no usuário ou dispositivo, reduzindo o risco de escalonamento de privilégios.

O exemplo a seguir concede permissão para baixar objetos correspondentes ao caminho sample-bucket/2015/01/01/*.jpg.

Exemplo de solicitação

aliyun sts AssumeRole --RoleArn 'acs:ram::123456789012****:role/oss-objectmanager' --RoleSessionName 'client-002' --Policy '{"Version":"1", "Statement": [{"Effect":"Allow", "Action":"oss:GetObject", "Resource":"acs:oss:*:*:sample-bucket/2015/01/01/*.jpg"}]}'

Nota

O tempo de expiração padrão de um token STS é de 3.600 segundos. Defina um tempo diferente utilizando o parâmetro DurationSeconds. Para mais informações, consulte AssumeRole.

Exemplo de resposta

{
   "AssumedRoleUser": {
       "AssumedRoleId": "391578752573****:client-002",
       "Arn": "acs:ram::123456789012****:role/oss-objectmanager/client-002"
   },
   "Credentials": {
       "AccessKeySecret": "yourAccessKeySecret",
       "SecurityToken": "yourSecurityToken",
       "Expiration": "2016-01-13T15:03:39Z",
       "AccessKeyId": "yourAccessKeyId"
   }, 
   "RequestId": "98835D9B-86E5-4BB5-A6DF-9D3156ABA567"
}

Use um token STS para acessar o OSS

O servidor de aplicativos transmite o token STS ao aplicativo móvel.

O aplicativo móvel utiliza o token STS para acessar o OSS.

O exemplo a seguir usa o OSS Android SDK para baixe um arquivo do OSS com um token STS.

// Replace yourEndpoint with the endpoint of the region where your bucket is located. For example, for the China (Hangzhou) region, the endpoint is https://oss-cn-hangzhou.aliyuncs.com.
String endpoint = "yourEndpoint";
// Replace yourRegion with the ID of the region where your bucket is located. For example, for the China (Hangzhou) region, the region ID is cn-hangzhou.
String region = "yourRegion";

// The temporary AccessKey ID and AccessKey Secret obtained from STS.
String accessKeyId = "yourAccessKeyId";
String accessKeySecret = "yourAccessKeySecret";
// The security token obtained from STS.
String securityToken = "yourSecurityToken";

OSSCredentialProvider credentialProvider = new OSSStsTokenCredentialProvider(accessKeyId, accessKeySecret, securityToken);
ClientConfiguration config = new ClientConfiguration();
config.setSignVersion(SignVersion.V4);
// Create an OSSClient instance.
OSSClient oss = new OSSClient(getApplicationContext(), endpoint, credentialProvider);
oss.setRegion(region);
// Construct a download request.
GetObjectRequest get = new GetObjectRequest("sample-bucket", "2015/01/01/grass.jpg");

OSSAsyncTask task = oss.asyncGetObject(get, new OSSCompletedCallback<GetObjectRequest, GetObjectResult>() {
    @Override
     // On success, the GetObject request returns a GetObjectResult containing an input stream. You must process the stream.
    public void onSuccess(GetObjectRequest request, GetObjectResult result) {
        // The request is successful.
        Log.d("asyncGetObject", "DownloadSuccess");
        Log.d("Content-Length", "" + result.getContentLength());
        
        try (InputStream inputStream = result.getObjectContent()) {
            byte[] buffer = new byte[2048];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
            // Process the data.
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    // The onFailure callback is triggered if the request fails. Handle the exception.
    public void onFailure(GetObjectRequest request, ClientException clientExcepion, ServiceException serviceException) {
        if (clientExcepion != null) {
            // Handle client-side exceptions, such as network errors.
            clientExcepion.printStackTrace();
        }
        if (serviceException != null) {
            // Handle service-side exceptions.
            Log.e("ErrorCode", serviceException.getErrorCode());
            Log.e("RequestId", serviceException.getRequestId());
            Log.e("HostId", serviceException.getHostId());
            Log.e("RawMessage", serviceException.getRawMessage());
        }
    }
});
// Cancel the task.
// task.cancel(); 
// Wait for the task to complete.
// task.waitUntilFinished();