Simple Log Service:,

Visão geral da solução

Considere que a Empresa A possui a conta Alibaba Cloud A e a Empresa B possui a conta Alibaba Cloud B. Para atender a requisitos como isolamento de negócios ou terceirização de projetos, a Empresa A deseja autorizar a Empresa B a gerenciar parte de seus recursos no Simple Log Service. Os requisitos são os seguintes:

• A conta Alibaba Cloud B tem permissão para gravar dados no Simple Log Service da conta Alibaba Cloud A e usar grupos de consumidores.

• O usuário RAM especificado da conta Alibaba Cloud B também possui permissões de gravação e de grupo de consumidores no Simple Log Service.

• A conta Alibaba Cloud B pode obter credenciais STS temporárias para acessar as operações de API do Simple Log Service. Para mais informações, consulte What is STS?.

  Com base nesses requisitos, execute as etapas a seguir para concluir a configuração:

1. Etapa 1: A conta Alibaba Cloud A cria e autoriza uma função RAM para a conta Alibaba Cloud B

2. Etapa 2: A conta Alibaba Cloud B cria e autoriza o usuário RAM user-b

3. Etapa 3: O usuário RAM user-b obtém credenciais STS temporárias

   Um exemplo completo em Java que chama a operação AssumeRole e grava dados no Simple Log Service está disponível em Código de exemplo.

Pré-requisitos

• Contas Alibaba Cloud: a conta Alibaba Cloud A é proprietária dos recursos do Simple Log Service, e a conta Alibaba Cloud B é a conta autorizada pela conta Alibaba Cloud A.

• Recursos do Simple Log Service: existem um projeto e um LogStore na conta Alibaba Cloud A. O usuário RAM da conta Alibaba Cloud B grava dados nesse projeto e LogStore.

Limites

Antes de configurar o acesso entre contas ao Simple Log Service, observe os seguintes limites:

• Identidade do chamador: apenas um usuário RAM (subconta) pode chamar a operação AssumeRole. O par de AccessKey de uma conta Alibaba Cloud não pode chamar o AssumeRole.

• Validade da credencial: o par de AccessKey temporário e o token de segurança expiram em uma hora. Chame a operação AssumeRole novamente após a expiração.

• Região: atualmente, o STS suporta apenas cn-hangzhou. Portanto, o projeto no qual você grava dados deve residir na região cn-hangzhou.

Etapa 1: A conta Alibaba Cloud A cria e autoriza uma função RAM para a conta Alibaba Cloud B

Na conta Alibaba Cloud A, crie uma função RAM, especifique a conta Alibaba Cloud B como a conta que assume a função e conceda à função as permissões especificadas do Simple Log Service.

Crie a função RAM no console RAM. As etapas a seguir descrevem o método via console em detalhes. Para criar a função RAM programaticamente, chame a operação CreateRole da API RAM. Para obter detalhes, consulte CreateRole. Para saber como criar identidades RAM e conceder permissões a elas, consulte Create a RAM user and grant permissions.

1. Faça login no console RAM com a conta Alibaba Cloud A.

2. Crie uma função RAM e especifique a conta Alibaba Cloud B como a conta que assume a função. Para obter instruções, consulte Create a RAM role for a trusted Alibaba Cloud account. Anote o ARN da função. A Etapa 3 usa o ARN como valor de RoleArn. Você pode obter o ARN na página de detalhes da função no console RAM: https://ram.console.alibabacloud.com/#/role/detail/<specified_rolename>/info.

3. Crie uma política personalizada. Na aba JSON da página Create Policy, substitua o script existente no editor de código pelo seguinte documento de política. Para mais informações, consulte Using the script editor.

   Selecione o script de autorização conforme as permissões concedidas à função RAM:

   • Apenas gravação de dados: use o script na aba Write data only.

   • Obtenção de dados usando a biblioteca de consumidores: use o script na aba Obtain data by using the consumer library.

   • (Recomendado para o cenário deste tópico) Permissões de gravação e de grupo de consumidores: mescle os dois scripts em um único documento de política. Mantenha "Version": "1", "Effect": "Allow" e "Resource": "*" inalterados e liste a ação da aba Write data only junto com as sete ações da aba Obtain data by using the consumer library em um único array Action. O cenário deste tópico requer permissões de gravação e de grupo de consumidores.

   Write data only

   Write data only

   {
     "Version": "1",
     "Statement": [
       {
         "Action": "log:PostLogStoreLogs",
         "Resource": "*",
         "Effect": "Allow"
       }
     ]
   }

   Obtain data by using the consumer library

   Obtain data by using the consumer library

   {
     "Version": "1",
     "Statement": [
       {
         "Action": [
            "log:GetCursorOrData",
            "log:CreateConsumerGroup",
            "log:ListConsumerGroup",
            "log:ConsumerGroupUpdateCheckPoint",
            "log:ConsumerGroupHeartBeat",
            "log:GetConsumerGroupCheckPoint",
            "log:UpdateConsumerGroup"
         ],
         "Resource": "*",
         "Effect": "Allow"
       }
     ]
   }

4. Anexe a política personalizada criada à função RAM. Para mais informações, consulte Manage permissions for a RAM role.

Etapa 2: A conta Alibaba Cloud B cria e autoriza o usuário RAM user-b

Na conta Alibaba Cloud B, crie o usuário RAM user-b e conceda a ele a política de sistema AliyunSTSAssumeRoleAccess, que permite chamar a operação AssumeRole do STS.

1. Faça login no console RAM com a conta Alibaba Cloud B.

2. Crie um usuário RAM chamado user-b. Em Access Mode, selecione Console Access e Using permanent AccessKey to access. Para mais informações, consulte Create a RAM user. Anote o AccessKey ID e o AccessKey secret do user-b. A Etapa 3 os utiliza para chamar a operação AssumeRole.

3. Anexe a política AliyunSTSAssumeRoleAccess ao usuário RAM. Assim, o usuário RAM pode assumir a função RAM para obter tokens do Security Token Service (STS). Para mais informações, consulte Manage RAM user permissions.

Etapa 3: O usuário RAM user-b obtém credenciais STS temporárias

Na conta Alibaba Cloud B, use o par de AccessKey do usuário RAM user-b para obter credenciais STS temporárias e, em seguida, use-as para acessar os recursos do Simple Log Service da conta Alibaba Cloud A. Esta etapa requer o ARN da função RAM da Etapa 1 e o par de AccessKey do user-b da Etapa 2.

1. Chame a operação AssumeRole do STS para obter um par de AccessKey temporário e um token. Para obter detalhes, consulte AssumeRole.

   Chame a operação usando um SDK do STS. Para obter detalhes, consulte STS SDK overview.

2. Chame operações de API do Simple Log Service com as credenciais temporárias. Para obter informações sobre os SDKs do Simple Log Service, consulte SDK Reference. Para ver um exemplo que chama o AssumeRole e grava dados, consulte Código de exemplo.

Código de exemplo

O código de exemplo a seguir baseia-se no SDK Java e usa o cenário em que o usuário RAM user-b grava dados em um projeto da conta Alibaba Cloud A usando o STS. O exemplo usa o SDK Java do Simple Log Service (pacotes com.aliyun.openservices.log) e o SDK do STS (pacotes com.aliyuncs). Antes de executar o exemplo, substitua o par de AccessKey, o ARN da função, o nome do projeto e o nome do LogStore pelos seus próprios valores.

package com.aliyun.openservices.log.sample;

import java.util.Date;
import java.util.Vector;

import com.aliyun.openservices.log.Client;
import com.aliyun.openservices.log.common.LogItem;
import com.aliyun.openservices.log.exception.LogException;
import com.aliyun.openservices.log.request.PutLogsRequest;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.http.ProtocolType;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;
import com.aliyuncs.sts.model.v20150401.AssumeRoleRequest;
import com.aliyuncs.sts.model.v20150401.AssumeRoleResponse;

public class StsSample {
      // STS currently supports only "cn-hangzhou".
      public static final String REGION_CN_HANGZHOU = "cn-hangzhou";
      // The current STS API version.
      public static final String STS_API_VERSION = "2015-04-01";
      static AssumeRoleResponse assumeRole(String accessKeyId, String accessKeySecret,
                                           String roleArn, String roleSessionName, String policy,
                                           ProtocolType protocolType) throws ClientException {
        try {
          // Construct an Alibaba Cloud AcsClient to call OpenAPI.
          IClientProfile profile = DefaultProfile.getProfile(REGION_CN_HANGZHOU, accessKeyId, accessKeySecret);
          DefaultAcsClient client = new DefaultAcsClient(profile);
          // Create an AssumeRoleRequest object.
          final AssumeRoleRequest request = new AssumeRoleRequest();
          request.setVersion(STS_API_VERSION);
          request.setMethod(MethodType.POST);
          request.setProtocol(protocolType);
          request.setRoleArn(roleArn);
          request.setRoleSessionName(roleSessionName);
          request.setPolicy(policy);
          // Send the request.
          final AssumeRoleResponse response = client.getAcsResponse(request);
          return response;
        } catch (ClientException e) {
          throw e;
        }
      }
      public static void main(String[] args) {
        // Only a RAM user (sub-account) can call the AssumeRole operation.
        // The AccessKey pair of an Alibaba Cloud account cannot call AssumeRole.
        // Create a RAM user in the RAM console (https://ram.console.alibabacloud.com) and create an AccessKey pair for this RAM user.
        String accessKeyId = "<subaccountaccesskey>";
        String accessKeySecret = "<subaccountaccesssecret>";
        // The AssumeRole API parameters are RoleArn, RoleSessionName, Policy, and DurationSeconds.
        // You can obtain the RoleArn in the RAM console.
        // https://ram.console.alibabacloud.com/#/role/detail/<specified_rolename>/info
        String roleArn = "<rolearn found in web console>";
        // RoleSessionName is the name of the temporary token, which is mainly used for auditing.
        String roleSessionName = "bluemix-001";
        String policy = "{\n" +
                "    \"Version\": \"1\", \n" +
                "    \"Statement\": [\n" +
                "        {\n" +
                "            \"Action\": \"log:PostLogStoreLogs\",\n" +
                "            \"Resource\": \"*\",\n" +
                "            \"Effect\": \"Allow\"\n" +
                "        }\n" +
                "    ]\n" +
                "}";
        System.out.println(policy);
        // Only HTTPS is supported here.
        ProtocolType protocolType = ProtocolType.HTTPS;
        AssumeRoleResponse response = new AssumeRoleResponse();
        try {
          response = assumeRole(accessKeyId, accessKeySecret,
                  roleArn, roleSessionName, policy, protocolType);
          System.out.println("Expiration: " + response.getCredentials().getExpiration());
          System.out.println("Access Key Id: " + response.getCredentials().getAccessKeyId());
          System.out.println("Access Key Secret: " + response.getCredentials().getAccessKeySecret());
          System.out.println("Security Token: " + response.getCredentials().getSecurityToken());
        } catch (ClientException e) {
          System.out.println("Failed to get a token.");
          System.out.println("Error code: " + e.getErrCode());
          System.out.println("Error message: " + e.getErrMsg());
        }

        // Simple Log Service parameters.
        // For information about Simple Log Service endpoints, see https://www.alibabacloud.com/help/en/sls/developer-reference/api-sls-2020-12-30-endpoint
        String logServiceEndpoint = "cn-hangzhou.log.aliyuncs.com";
        // This means that the project must reside in the cn-hangzhou region.
        String project = "<log service project name>";
        String logstore = "<log service logstore name>";

        // Construct a Simple Log Service client object.
        Client client = new Client(logServiceEndpoint, 
                response.getCredentials().getAccessKeyId(), 
                response.getCredentials().getAccessKeySecret());
        // Note: The AccessKey pair and the security token expire in one hour.
        // You must call the AssumeRole operation again after they expire.
        client.SetSecurityToken(response.getCredentials().getSecurityToken());
        Vector<LogItem> logGroup = new Vector<LogItem>();
        LogItem logItem = new LogItem((int) (new Date().getTime() / 1000));
        logItem.PushBack("StsSample", "Send Data");
        logGroup.add(logItem);

        PutLogsRequest req2 = new PutLogsRequest(project, logstore, "", "", logGroup);
        try {
            client.PutLogs(req2);
        } catch (LogException e) {
            System.out.println("Failed to send data.");
            System.out.println("Error code: " + e.GetErrorCode());
            System.out.println("Error message: " + e.GetErrorMessage());
        }
      }
}

Quando a chamada AssumeRole é bem-sucedida, o exemplo imprime o tempo de expiração das credenciais, o AccessKey ID temporário, o AccessKey secret e o token de segurança. Se a chamada falhar, o exemplo imprime Failed to get a token. com o código de erro e a mensagem de erro. Se a gravação de dados falhar, o exemplo imprime Failed to send data. com o código de erro e a mensagem de erro do Simple Log Service.