Lab 38 — Multi-tenant: linha, schema ou conta

# prova-vazamento.sh — o vazamento medido, antes de qualquer teste automatizado
# Rodado contra a base de EXEMPLO deste laboratorio (340 tenants semeados).

$ psql "$DATABASE_URL" -c \
  "SELECT tenant_id, count(*) FROM pedidos GROUP BY tenant_id ORDER BY 2 DESC LIMIT 3"
              tenant_id               | count
---------------------------------------+-------
 3f29a7c1-...-cadencia                 |  1842
 7b41f0aa-...-sapataria-nordeste       |   931
 9c02e5bb-...-armarinho-tres-marias    |   604

# Autenticado como operador da Sapataria Nordeste, chamando a rota nova:
$ curl -s -H "Authorization: Bearer $TOKEN_SAPATARIA" \
  "$HOST/painel/metricas-agregadas" | jq '.totalGeral, .tenantsNaResposta'
274193.50
["cadencia", "sapataria-nordeste", "armarinho-tres-marias", "... 337 outros"]

# O numero e a soma de TODOS os 340 tenants. Uma operadora que so deveria
# enxergar a propria loja recebeu o faturamento de 339 concorrentes junto.

// VazamentoEntreTenantsTests.cs — a prova do defeito, nao a descricao dele
//
// Roda contra um Postgres real via Testcontainers (nao mock: RLS e uma
// garantia do MOTOR, e so o motor de verdade prova ou desmente ela). Semeia
// dois tenants na mesma tabela e chama a consulta exata do endpoint que
// vazou em producao -- sem NENHUMA linha de contexto de tenant por baixo,
// porque o desenho minimo nao tem nenhuma.

public class VazamentoEntreTenantsTests : IAsyncLifetime
{
    private readonly PostgreSqlContainer _pg =
        new PostgreSqlBuilder().WithImage("postgres:16").Build();

    public async Task InitializeAsync() => await _pg.StartAsync();
    public async Task DisposeAsync() => await _pg.DisposeAsync();

    [Fact(DisplayName = "Consulta sem WHERE tenant_id devolve mais de um tenant")]
    public async Task PainelDeMetricas_NaoFiltraTenant()
    {
        await using var ds = NpgsqlDataSource.Create(_pg.GetConnectionString());
        await CriarTabelaSemRlsAsync(ds);   // so a tabela; nenhuma politica

        await SemearAsync(ds, tenantId: TenantCadencia, quantidadeDePedidos: 1842);
        await SemearAsync(ds, tenantId: TenantSapatariaNordeste, quantidadeDePedidos: 931);

        // A MESMA consulta do endpoint /painel/metricas-agregadas que vazou em
        // producao: agrega pedidos por tenant, sem clausula de tenant nenhuma.
        await using var cmd = ds.CreateCommand(
            "SELECT tenant_id, SUM(total) FROM pedidos GROUP BY tenant_id");
        await using var reader = await cmd.ExecuteReaderAsync();

        var tenantsNaResposta = new HashSet<Guid>();
        while (await reader.ReadAsync())
            tenantsNaResposta.Add(reader.GetGuid(0));

        // FALHA DE PROPOSITO no desenho minimo -- e a prova gravada do
        // defeito, nao uma descricao dele. Uma unica sessao autenticada como
        // Sapataria Nordeste nao deveria enxergar o tenant Cadencia junto.
        Assert.True(tenantsNaResposta.Count == 1,
            $"VAZAMENTO CONFIRMADO: {tenantsNaResposta.Count} tenants distintos " +
            "apareceram na resposta de uma unica sessao autenticada.");
    }
}

// access token decodificado (payload) -- o que a API realmente recebe
{
  "sub": "3f29a7c1-...",
  "iss": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_XXXXXXX",
  "client_id": "5g8h...",
  "token_use": "access",
  "scope": "rotafacil-api/pedidos.leitura",
  // Esta claim NAO existe por padrao no access token. Ela so aparece porque
  // o gatilho de pre-geracao de token, versao 2, foi configurado para
  // escreve-la em accessTokenGeneration.claimsToAddOrOverride -- a versao 1
  // do gatilho so alcanca o ID token, que a API nunca ve.
  "custom:tenant_id": "7b41f0aa-2222-4444-8888-sapataria-nordeste",
  "exp": 1723046400,
  "iat": 1723042800
}

-- rls.sql — a fronteira desce do codigo da aplicacao para o motor do banco

-- O papel que a aplicacao usa NUNCA pode ter BYPASSRLS nem ser dono da tabela.
-- Sao os dois jeitos silenciosos de a protecao abaixo nao valer para ninguem.
CREATE ROLE app_rotafacil LOGIN PASSWORD '(via Secrets Manager, nunca aqui)'
  NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE;

GRANT SELECT, INSERT, UPDATE, DELETE ON pedidos TO app_rotafacil;
GRANT USAGE ON SCHEMA public TO app_rotafacil;

-- Habilita a politica de linha na tabela.
ALTER TABLE pedidos ENABLE ROW LEVEL SECURITY;

-- FORCE fecha a brecha mais comum: sem ele, o DONO da tabela (tipicamente o
-- papel que roda migration) continua ignorando a politica. Isso pega quem usa
-- o mesmo papel para aplicacao e para migration -- erro comum de day one.
ALTER TABLE pedidos FORCE ROW LEVEL SECURITY;

-- A politica. USING filtra LEITURA; WITH CHECK filtra ESCRITA -- sem o
-- segundo, um INSERT ou UPDATE poderia gravar tenant_id de outro cliente,
-- mesmo que a leitura subsequente ja estivesse protegida.
CREATE POLICY isolamento_por_tenant ON pedidos
  USING      (tenant_id = current_setting('app.tenant_id', true)::uuid)
  WITH CHECK (tenant_id = current_setting('app.tenant_id', true)::uuid);

-- O segundo argumento `true` de current_setting evita excecao quando a
-- variavel de sessao nao foi definida (conexao sem contexto de tenant): a
-- politica compara tenant_id com NULL, que nunca e verdadeiro, e a consulta
-- devolve ZERO linhas em vez de estourar erro. Fail-closed, nao fail-open --
-- uma conexao que "esqueceu" de declarar o tenant nao ve nada, nunca ve tudo.

-- Indice composto: toda politica de RLS vira um predicado extra em CADA
-- consulta, entao tenant_id precisa estar na esquerda de todo indice usado
-- por rota quente, ou o ganho de RLS custa um scan sequencial por chamada.
CREATE INDEX idx_pedidos_tenant_criado ON pedidos (tenant_id, criado_em DESC);

// TenantContext.cs — a claim assinada vira contexto de sessao, por transacao

public sealed class TenantContextMiddleware
{
    private readonly RequestDelegate _proximo;

    public TenantContextMiddleware(RequestDelegate proximo) => _proximo = proximo;

    public async Task InvokeAsync(HttpContext ctx)
    {
        // A claim so existe porque o gatilho de pre-geracao de token (v2) a
        // escreveu no access token. Se ela nao estiver aqui, a requisicao nao
        // tem tenant -- e e rejeitada, nao assumida como "publica".
        var raw = ctx.User.FindFirst("custom:tenant_id")?.Value;
        if (!Guid.TryParse(raw, out var tenantId))
        {
            ctx.Response.StatusCode = StatusCodes.Status403Forbidden;
            return;
        }

        ctx.Items["TenantId"] = tenantId;
        await _proximo(ctx);
    }
}

// Repositorio base: TODA consulta passa por aqui, e a declaracao do tenant e
// a PRIMEIRA instrucao da transacao -- antes de qualquer SELECT do caso de uso.
public abstract class RepositorioComTenant
{
    private readonly NpgsqlDataSource _dataSource;
    private readonly IHttpContextAccessor _http;

    protected RepositorioComTenant(NpgsqlDataSource dataSource, IHttpContextAccessor http)
    {
        _dataSource = dataSource;
        _http = http;
    }

    protected async Task<NpgsqlConnection> AbrirComTenantAsync(NpgsqlTransaction tx)
    {
        var tenantId = (Guid)_http.HttpContext!.Items["TenantId"]!;

        // `SET LOCAL app.tenant_id = @id` NAO existe como comando parametrizavel
        // -- o protocolo SET nao aceita bind parameter. `set_config(..., true)`
        // e a forma segura e parametrizavel: o terceiro argumento `true` e
        // exatamente o que `SET LOCAL` faz -- o valor vale so ate o COMMIT ou
        // ROLLBACK da transacao atual.
        //
        // Isto e o que torna seguro reusar conexao de um pool: a proxima
        // transacao na MESMA conexao fisica nao herda o tenant_id da anterior,
        // porque ele nunca sobreviveu ao fim da transacao passada.
        await using var cmd = new NpgsqlCommand(
            "SELECT set_config('app.tenant_id', $1, true)", tx.Connection, tx);
        cmd.Parameters.AddWithValue(tenantId.ToString());
        await cmd.ExecuteNonQueryAsync();

        return tx.Connection!;
    }
}

public sealed class PedidosRepositorio : RepositorioComTenant
{
    public PedidosRepositorio(NpgsqlDataSource ds, IHttpContextAccessor http) : base(ds, http) { }

    public async Task<IReadOnlyList<Pedido>> ListarAsync(NpgsqlTransaction tx)
    {
        var conn = await AbrirComTenantAsync(tx);

        // Sem WHERE tenant_id. De proposito: a linha abaixo e IDENTICA ao
        // endpoint que vazou no desenho minimo. A diferenca inteira do
        // resultado vem da politica de RLS que o banco aplica por baixo.
        await using var cmd = new NpgsqlCommand("SELECT id, tenant_id, total FROM pedidos", conn, tx);
        await using var reader = await cmd.ExecuteReaderAsync();

        var pedidos = new List<Pedido>();
        while (await reader.ReadAsync())
            pedidos.Add(new Pedido(reader.GetGuid(0), reader.GetGuid(1), reader.GetDecimal(2)));
        return pedidos;
    }
}

-- provisionar_schema.sql — o preco do isolamento por schema: on-boarding vira DDL

-- Chamado pela funcao de on-boarding quando um tenant novo assina o plano
-- "schema dedicado". O nome do schema NUNCA vem direto do input do usuario --
-- vai por um identificador interno gerado pela aplicacao, para impedir
-- injecao via nome de schema (identifiers nao aceitam parametro ligado).
CREATE OR REPLACE FUNCTION provisionar_schema_tenant(p_tenant_slug text)
RETURNS void AS $$
DECLARE
  v_schema text := 'tenant_' || p_tenant_slug;
BEGIN
  EXECUTE format('CREATE SCHEMA %I', v_schema);

  -- Clona a estrutura de um schema-molde (`_template`) mantido em migration.
  -- Isto e o efeito colateral que o modelo por schema cobra: uma migration
  -- que no modelo por linha e UM comando aqui vira um loop sobre N schemas.
  EXECUTE format(
    'CREATE TABLE %I.pedidos (LIKE _template.pedidos INCLUDING ALL)', v_schema);
  EXECUTE format(
    'CREATE TABLE %I.itens_pedido (LIKE _template.itens_pedido INCLUDING ALL)', v_schema);

  -- O papel de aplicacao ganha USAGE apenas no schema deste tenant -- ele
  -- continua sem enxergar os outros 339 por falta de GRANT, nao por politica.
  EXECUTE format('GRANT USAGE ON SCHEMA %I TO app_rotafacil', v_schema);
  EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA %I TO app_rotafacil', v_schema);
END;
$$ LANGUAGE plpgsql;

#!/usr/bin/env bash
# migrar_todos_os_schemas.sh — a migration que era um comando virou um laco
set -euo pipefail

# No modelo por linha, aplicar uma migration e UM `dotnet ef database update`.
# Aqui, e este laco -- e ele cresce linearmente com o numero de tenants no
# plano "schema dedicado", nao com o tamanho da mudanca.
SCHEMAS=$(psql "$DATABASE_URL" -tAc \
  "SELECT nspname FROM pg_namespace WHERE nspname LIKE 'tenant_%'")

falhas=0
for schema in $SCHEMAS; do
  echo "migrando ${schema}..."
  # search_path troca o alvo do runner de migration SEM duplicar a conexao.
  if ! psql "$DATABASE_URL" -v ON_ERROR_STOP=1 \
       -c "SET search_path TO ${schema}, public;" \
       -f migrations/2026_08_07_add_coluna_prioridade.sql; then
    echo "FALHOU em ${schema} -- os demais continuam, mas este tenant fica na versao antiga" >&2
    falhas=$((falhas+1))
  fi
done

# Uma migration parcialmente aplicada -- alguns schemas na v42, outros na v41
# -- e o modo de falha caracteristico deste modelo, e ele nao existe no
# modelo por linha (onde ha uma tabela so, uma transacao so).
echo "concluido: ${falhas} schema(s) com falha"
[ "$falhas" -eq 0 ]

# conta.tf — o modelo por conta: a fronteira e a propria conta AWS

# Uma conta de membro por tenant grande. O nome e o e-mail raiz sao gerados
# pela plataforma, nunca digitados a mao -- isso e o que permite este
# recurso ser criado por automacao de on-boarding, nao por ticket manual.
resource "aws_organizations_account" "tenant" {
  for_each = var.tenants_enterprise   # ex.: { "cadencia" = {...}, "outraloja" = {...} }

  name      = "rotafacil-tenant-${each.key}"
  email     = "aws-tenant-${each.key}@rotafacil.example.com"
  parent_id = aws_organizations_organizational_unit.tenants_enterprise.id

  # SCPs anexados a esta OU sao o TETO do que a conta pode fazer, mesmo que
  # o IAM local permita mais -- e a fronteira de governanca que nenhum
  # `Resource: "*"` de dentro da conta consegue furar.
  role_name = "OrganizationAccountAccessRole"

  lifecycle {
    prevent_destroy = true   # fechar conta por engano perde os dados do tenant
  }
}

# O time da plataforma acessa a conta do tenant assumindo um papel -- nunca
# com credencial de longa duracao criada dentro da conta do cliente.
data "aws_iam_policy_document" "confianca_cross_account" {
  statement {
    effect  = "Allow"
    actions = ["sts:AssumeRole"]

    principals {
      type        = "AWS"
      identifiers = [var.conta_plataforma_arn]
    }

    # ExternalId evita o problema do "deputado confuso": sem ele, qualquer
    # entidade que descubra o ARN do papel na conta do tenant poderia
    # assumi-lo. Com ele, so quem tambem conhece o segredo compartilhado passa.
    condition {
      test     = "StringEquals"
      variable = "sts:ExternalId"
      values   = [var.external_id_por_tenant[each.key]]
    }
  }
}

resource "aws_iam_role" "acesso_plataforma" {
  provider           = aws.tenant_account
  for_each           = var.tenants_enterprise
  name               = "PlataformaRotafacilAcesso"
  assume_role_policy = data.aws_iam_policy_document.confianca_cross_account.json
  max_session_duration = 3600   # credencial de sessao curta, nunca de longa duracao
}

{
  "// comentario": "policy de exemplo -- JSON real nao aceita comentario",
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["dynamodb:GetItem", "dynamodb:Query"],
    "Resource": "arn:aws:dynamodb:us-east-1:111122223333:table/pedidos",
    "Condition": {
      "ForAllValues:StringLike": {
        "dynamodb:LeadingKeys": ["${aws:PrincipalTag/tenant_id}*"]
      }
    }
  }]
}

# canario.py — o vigia que tenta vazar dado a cada 5 minutos
import os
import boto3
import psycopg

TENANT_TESTE = os.environ["TENANT_TESTE_ID"]          # tenant so para o canario
TENANT_ALVO = os.environ["TENANT_ALVO_ID"]            # tenant "vizinho" no teste
cloudwatch = boto3.client("cloudwatch")

def handler(event, context):
    with psycopg.connect(os.environ["DATABASE_URL"]) as conn:
        with conn.cursor() as cur:
            # Declara o tenant de teste -- exatamente como a API declararia.
            cur.execute("SELECT set_config('app.tenant_id', %s, true)", (TENANT_TESTE,))

            # Tenta, de proposito, ler uma linha marcada como pertencente ao
            # tenant "vizinho". Numa fronteira que funciona, zero linhas.
            cur.execute(
                "SELECT count(*) FROM pedidos WHERE tenant_id = %s", (TENANT_ALVO,)
            )
            vazou = cur.fetchone()[0]

        conn.rollback()  # o set_config e transacional; isto tambem o descarta

    cloudwatch.put_metric_data(
        Namespace="Rotafacil/IsolamentoTenant",
        MetricData=[{
            "MetricName": "LinhasVazadasNoCanario",
            "Value": float(vazou),
            "Unit": "Count",
        }],
    )

    if vazou > 0:
        # Nao levanta excecao silenciosa -- o alarme do CloudWatch e quem
        # acorda alguem, mas o log entra na trilha de qualquer forma.
        print(f"ALERTA: canario leu {vazou} linha(s) do tenant vizinho")

    return {"linhasVazadas": vazou}

// VazamentoEntreTenantsTests.cs — o MESMO ataque, contra o desenho de producao
//
// O teste da secao anterior falhava (vermelho) porque nao havia fronteira
// nenhuma abaixo da aplicacao. Este arquivo reusa o mesmo ataque -- a mesma
// consulta sem WHERE -- mas agora contra a infraestrutura real deste modulo:
// tabela com FORCE ROW LEVEL SECURITY e o repositorio que declara o tenant
// via set_config antes de consultar.

public class VazamentoEntreTenantsTests : IAsyncLifetime
{
    private readonly PostgreSqlContainer _pg =
        new PostgreSqlBuilder().WithImage("postgres:16").Build();

    public async Task InitializeAsync() => await _pg.StartAsync();
    public async Task DisposeAsync() => await _pg.DisposeAsync();

    [Fact(DisplayName = "Com RLS obrigatoria, a mesma consulta sem WHERE nunca vaza")]
    public async Task PainelDeMetricas_NuncaExpoeOutroTenant()
    {
        await using var ds = NpgsqlDataSource.Create(_pg.GetConnectionString());
        await AplicarRlsSqlAsync(ds);   // executa rls.sql sobre o container real

        await SemearAsync(ds, tenantId: TenantCadencia, quantidadeDePedidos: 1842);
        await SemearAsync(ds, tenantId: TenantSapatariaNordeste, quantidadeDePedidos: 931);

        var http = new HttpContextAccessorFalso(tenantId: TenantSapatariaNordeste);
        var repo = new PedidosRepositorio(ds, http);

        await using var conn = await ds.OpenConnectionAsync();
        await using var tx = await conn.BeginTransactionAsync();

        // O MESMO SQL sem WHERE do teste anterior -- o repositorio nunca
        // filtra por tenant no C#. Quem filtra e a politica no Postgres.
        var pedidos = await repo.ListarAsync(tx);

        Assert.All(pedidos, p => Assert.Equal(TenantSapatariaNordeste, p.TenantId));
        // Verde: nenhuma linha da Cadencia atravessou, mesmo com a consulta
        // exatamente igual a que vazou no desenho minimo.
    }
}

#!/usr/bin/env bash
set -euo pipefail

# 1. Remove o canario agendado ANTES de remover o banco, senao ele passa a
#    falhar em loop tentando alcancar uma instancia que ja nao existe.
aws events remove-targets --rule canario-isolamento --ids canario
aws events delete-rule --rule-name canario-isolamento

# 2. Schemas de tenant NAO fazem parte do estado do Terraform -- foram
#    criados por funcao SQL (provisionar_schema_tenant), entao sao removidos
#    por SQL tambem. Confirme que nao ha uso ativo antes de derrubar.
psql "$DATABASE_URL" -c "SELECT nspname FROM pg_namespace WHERE nspname LIKE 'tenant_%'"
# DROP SCHEMA tenant_xxx CASCADE;  -- um por vez, de proposito, nunca em lote

# 3. Contas de tenant (Organizations) NAO fecham com terraform destroy por
#    padrao -- aws_organizations_account so remove a conta da ORGANIZACAO,
#    nao fecha a conta AWS. Fechar de fato exige a API de fechamento de conta
#    ou o console, e tem janela de 90 dias antes de poder reingressar numa
#    organizacao. Planeje isso ANTES de prometer "encerramento imediato" a um
#    tenant que sai.

terraform destroy -auto-approve