Implementando uma arquitetura de Authorizer para aplicações entregues no modelo SaaS (Software as a Service) na AWS

Compartilho com vocês um tutorial técnico sobre como implementar uma arquitetura de Authorizer para aplicações entregues no modelo SaaS (Software as a Service) na AWS, levando em consideração três níveis de serviço: Gold, Silver e Bronze. Essa arquitetura permitirá autorizar o acesso dos usuários a tenants diferentes, de acordo com seu nível de serviço, oferecendo recursos computacionais e capacidade de resposta adequados às suas necessidades.

Vamos dividir o tutorial em várias etapas para facilitar a compreensão e implementação.

1. Definindo a estrutura do sistema:

Antes de começar a implementar a arquitetura de Authorizer, é importante definir a estrutura do sistema. Nesse caso, teremos três tiers de serviço: Gold, Silver e Bronze. Cada tier terá seus próprios recursos computacionais e capacidade de resposta. Além disso, precisaremos de um mecanismo de autenticação para verificar as credenciais dos usuários e determinar o tier ao qual eles pertencem.

2. Configurando a autenticação de usuários:

Para implementar a autenticação de usuários, podemos usar o Amazon Cognito, que oferece serviços de autenticação, autorização e gerenciamento de usuários. Siga estas etapas para configurar a autenticação de usuários:

2.1. Crie um pool de usuários no Amazon Cognito para sua aplicação SaaS. Defina as opções de autenticação, como login com nome de usuário/senha ou login social.

2.2. Configure os fluxos de autenticação e personalização de acordo com suas necessidades. Você pode definir atributos personalizados para armazenar informações adicionais sobre os usuários, como seu nível de serviço.

2.3. No momento do registro ou posteriormente, atribua aos usuários um atributo personalizado que represente seu nível de serviço (por exemplo, “tier” com os valores “gold”, “silver” ou “bronze”).

3. Implementando o Authorizer:

Agora, vamos implementar a lógica do Authorizer para determinar o tier do usuário e autorizar o acesso ao tenant correspondente. Nesse exemplo, usaremos o AWS Lambda para criar uma função de autorização.

3.1. Crie uma nova função AWS Lambda no console da AWS ou usando a AWS CLI. Certifique-se de selecionar a linguagem de programação de sua preferência.

3.2. Defina os gatilhos da função Lambda para serem acionados no momento da autenticação do usuário. Isso dependerá do serviço de autenticação que você está usando. Por exemplo, se estiver usando o Amazon Cognito, defina o gatilho para ser acionado quando um usuário autenticar com sucesso.

3.3. Dentro da função Lambda, recupere as informações do usuário autenticado (por exemplo, seu nome de usuário, ID ou atributos personalizados) usando os eventos de gatilho fornecidos.

3.4. Com base nas informações do usuário, determine o tier ao qual ele pertence. Isso pode ser feito verificando o valor do atributo personalizado definido anteriormente (por exemplo, “tier” sendo “gold”, “silver” ou “bronze”).

3.5. Com base no tier do usuário, você pode usar a AWS Identity and Access Management (IAM) para conceder permissões de acesso a recursos específicos, como bancos de dados ou instâncias de servidor, associados a cada tenant. Configure as políticas do IAM para permitir ou negar acesso aos recursos com base no tier do usuário.

4. Implementando a segregação de tenants:

Para garantir a segregação de tenants e fornecer recursos computacionais e capacidade de resposta adequados a cada tier de serviço, você pode usar diferentes instâncias de servidores ou bancos de dados para cada tenant. Siga estas etapas para implementar a segregação de tenants:

4.1. Crie instâncias separadas de servidores ou bancos de dados para cada tier de serviço. Por exemplo, você pode ter uma instância de servidor separada para clientes Gold, outra para clientes Silver e outra para clientes Bronze.

4.2. Ao conceder permissões de acesso aos recursos usando as políticas do IAM, defina permissões apropriadas para cada tier. Por exemplo, clientes Gold podem ter acesso total aos recursos, enquanto clientes Silver podem ter acesso limitado e clientes Bronze podem ter acesso mínimo.

4.3. Ao responder às requisições dos usuários, consulte as informações de autenticação e autorização para determinar o tier do usuário. Com base no tier, redirecione a requisição para a instância de servidor ou banco de dados apropriada.

5. Testando e monitorando:

Após a implementação, é importante realizar testes abrangentes para garantir que a arquitetura de Authorizer esteja funcionando corretamente. Certifique-se de testar diferentes cenários, como usuários em diferentes tiers e acessando recursos apropriados.

Além disso, configure monitoramento adequado usando serviços como o Amazon CloudWatch para acompanhar o desempenho e a escalabilidade da sua aplicação SaaS. Isso ajudará a identificar quaisquer problemas de desempenho ou gargalos na arquitetura.

Espero que este tutorial seja útil para você implementar a arquitetura de Authorizer para sua aplicação SaaS na AWS, considerando três tiers de serviço. Lembre-se de adaptar as etapas às suas necessidades específicas e às tecnologias que você está usando. Boa sorte em sua implementação!

A seguir comparitlho o código CloudFormation para implementar cada uma das etapas mencionadas anteriormente, incluindo as funções Lambda em Python. Lembre-se de ajustar os recursos e parâmetros de acordo com suas necessidades específicas.

Etapa 1: Definindo a estrutura do sistema

Resources:
  MySaaSSystem:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: path/to/your/template.yaml
      Parameters:
        - Tier: Gold
        - Tier: Silver
        - Tier: Bronze

Etapa 2: Configurando a autenticação de usuários

Resources:
  UserPool:
    Type: AWS::Cognito::UserPool
    Properties:
      UserPoolName: MyUserPool
      Policies:
        PasswordPolicy:
          MinimumLength: 8
          RequireLowercase: true
          RequireUppercase: true
          RequireNumbers: true
          RequireSymbols: true
      UsernameAttributes:
        - email
      AutoVerifiedAttributes:
        - email
      Schema:
        - Name: tier
          AttributeDataType: String
          Mutable: true
UserPoolClient:
    Type: AWS::Cognito::UserPoolClient
    Properties:
      UserPoolId: !Ref UserPool
      ClientName: MyAppClient

Etapa 3: Implementando o Authorizer (Lambda)

Resources:
  AuthAuthorizer:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: AuthAuthorizer
      Runtime: python3.8
      Handler: index.lambda_handler
      Code:
        ZipFile: |
          import jsondef lambda_handler(event, context):
              # Recupere as informações do usuário autenticado a partir do evento de gatilho
              # Implemente a lógica para determinar o tier do usuário com base nas informações do usuário
              # Retorne uma política IAM adequada com base no tier do usuário
              if user_tier == "gold":
                  policy = {
                      "Version": "2012-10-17",
                      "Statement": [
                          {
                              "Effect": "Allow",
                              "Action": [
                                  "ec2:*",
                                  "rds:*"
                              ],
                              "Resource": "*"
                          }
                      ]
                  }
              elif user_tier == "silver":
                  policy = {
                      "Version": "2012-10-17",
                      "Statement": [
                          {
                              "Effect": "Allow",
                              "Action": [
                                  "ec2:Describe*"
                              ],
                              "Resource": "*"
                          }
                      ]
                  }
              elif user_tier == "bronze":
                  policy = {
                      "Version": "2012-10-17",
                      "Statement": [
                          {
                              "Effect": "Allow",
                              "Action": [
                                  "ec2:DescribeInstances"
                              ],
                              "Resource": "*"
                          }
                      ]
                  }
              else:
                  # Caso o tier não seja reconhecido, retorne uma política vazia ou uma política de negação
                  policy = {
                      "Version": "2012-10-17",
                      "Statement": [
                          {
                              "Effect": "Deny",
                              "Action": "*",
                              "Resource": "*"
                          }
                      ]
                  }
              return {
                  "principalId": "user",
                  "policyDocument": policy
              }
      Role: !GetAtt AuthAuthorizerRole.Arn
  AuthAuthorizerRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: AuthAuthorizerRole
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: AuthAuthorizerPolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - cognito-idp:AdminGetUser
                  - cognito-idp:AdminUpdateUserAttributes
                Resource: "*"

Etapa 4: Implementando a segregação de tenants

Resources:
  GoldTierServer:
    Type: AWS::EC2::Instance
    Properties:
      # Configurações da instância GoldTierServer
SilverTierServer:
    Type: AWS::EC2::Instance
    Properties:
      # Configurações da instância SilverTierServer
  BronzeTierServer:
    Type: AWS::EC2::Instance
    Properties:
      # Configurações da instância BronzeTierServer

Etapa 5: Testando e monitorando

Resources:
  MyMonitoringDashboard:
    Type: AWS::CloudWatch::Dashboard
    Properties:
      DashboardName: MyMonitoringDashboard
      DashboardBody: >
        {
          "widgets": [
            {
              "type": "metric",
              "x": 0,
              "y": 0,
              "width": 12,
              "height": 6,
              "properties": {
                "view": "timeSeries",
                "stacked": false,
                "metrics": [
                  [ "AWS/EC2", "CPUUtilization", "InstanceId", "i-0123456789abcdef0", { "label": "GoldTierServer" } ],
                  [ "AWS/EC2", "CPUUtilization", "InstanceId", "i-0123456789abcdef1", { "label": "SilverTierServer" } ],
                  [ "AWS/EC2", "CPUUtilization", "InstanceId", "i-0123456789abcdef2", { "label": "BronzeTierServer" } ]
                ],
                "region": "us-east-1"
              }
            }
          ]
        }

Lembre-se de substituir os comentários # Configurações pelos valores adequados para suas instâncias de servidor, como tipo de instância, imagem AMI, chaves SSH, etc.

Espero que esses exemplos de código CloudFormation em YAML e as funções Lambda em Python possam ajudá-lo a implementar a arquitetura de Authorizer para sua aplicação SaaS na AWS. Certifique-se de ajustar o código conforme necessário para suas necessidades específicas.

Até o próximo post! =)