Lab 69 — Governança do lake: permissão por coluna

# Rode ANTES de qualquer correcao — o numero que sai daqui e a linha de base.
aws athena start-query-execution \
  --query-string "SELECT * FROM cadencia_lake.prata_pedidos LIMIT 5" \
  --query-execution-context Database=cadencia_lake \
  --result-configuration OutputLocation=s3://cadencia-lake/atenas-resultados/

aws athena get-query-results --query-execution-id "$(terraform output -raw ultima_execucao)" \
  --query 'ResultSet.ResultSetMetadata.ColumnInfo[].Name'
# Esperado hoje: 12 colunas, incluindo cpf_cliente, nome_cliente, telefone_cliente e
# margem_custo_centavos — nenhuma marcada, nenhuma excluida. E a linha de base que
# a secao de prova, mais adiante, compara com o numero depois da correcao.

// Esquema SIMPLIFICADO e ILUSTRATIVO de um evento de acesso do Lake Formation no CloudTrail —
// inspecione um evento real no seu console antes de decidir logica em cima de um campo que nao
// esta confirmado aqui.
{
  "eventSource": "lakeformation.amazonaws.com",
  "eventName": "GetDataAccess",
  "userIdentity": { "arn": "arn:aws:sts::111122223333:assumed-role/cadencia-atendimento/theo" },
  "requestParameters": {
    "tableArn": "arn:aws:glue:us-east-1:111122223333:table/cadencia_lake/prata_pedidos",
    "permissions": ["SELECT"]
  },
  "additionalEventData": {
    // colunas efetivamente resolvidas para este principal — 8, nao 12
    "resolvedColumnCount": 8
  },
  "errorCode": null
}

# lake-formation-tags.tf — registra o recurso no LF e cria as tags de sensibilidade

# ATENCAO: este recurso e por CONTA — sobrescreve a lista de admins inteira se outro
# laboratorio tambem a declarar separadamente. Confira a lista existente antes de aplicar.
resource "aws_lakeformation_data_lake_settings" "admin" {
  admins = [data.aws_iam_session_context.atual.issuer_arn]
}

# Registrar aqui e o que faz o Lake Formation passar a ser a AUTORIDADE sobre o recurso —
# sem isso, IAM e a policy do bucket continuam decidindo sozinhos, e as tags abaixo nao
# valem nada: e o Data Lake Location que coloca o LF no caminho da consulta.
resource "aws_lakeformation_resource" "lake_cadencia" {
  arn = "arn:aws:s3:::cadencia-lake"
}

resource "aws_lakeformation_lf_tag" "sensibilidade" {
  key    = "sensibilidade"
  values = ["pii", "financeiro", "publico"]
}

locals {
  # As 3 colunas de dado pessoal, adicionadas por Produto — exigencia da NF-e.
  colunas_pii = ["cpf_cliente", "nome_cliente", "telefone_cliente"]

  # A coluna de dado financeiro interno, adicionada por Financeiro.
  colunas_financeiro = ["margem_custo_centavos"]
}

# Associar a tag aqui, no MESMO modulo Terraform que acompanha o schema do L65, e o que
# evita a tag ficar para tras quando uma coluna nova entrar — ver o requisito 6 da secao 3.
resource "aws_lakeformation_resource_lf_tags" "pii" {
  for_each = toset(local.colunas_pii)

  table_with_columns {
    database_name = "cadencia_lake"
    name          = "prata_pedidos"
    column_names  = [each.value]
  }

  lf_tag {
    key   = aws_lakeformation_lf_tag.sensibilidade.key
    value = "pii"
  }
}

resource "aws_lakeformation_resource_lf_tags" "financeiro" {
  for_each = toset(local.colunas_financeiro)

  table_with_columns {
    database_name = "cadencia_lake"
    name          = "prata_pedidos"
    column_names  = [each.value]
  }

  lf_tag {
    key   = aws_lakeformation_lf_tag.sensibilidade.key
    value = "financeiro"
  }
}

# As 8 colunas restantes NAO recebem tag — ausencia de tag e o que a concessao de
# 'publico' (b9) usa para liberar acesso, sem listar cada coluna uma a uma.

# lake-formation-permissoes.tf — GRANT por tag, nunca por nome de analista

# Atendimento: so as colunas SEM tag de sensibilidade (as 8 'publico').
resource "aws_lakeformation_permissions" "atendimento" {
  principal   = aws_iam_role.atendimento.arn
  permissions = ["SELECT"]

  lf_tag_policy {
    resource_type = "TABLE"
    expression {
      key    = aws_lakeformation_lf_tag.sensibilidade.key
      values = ["publico"]
    }
  }
  # NAO concede 'pii' nem 'financeiro' — e a AUSENCIA da tag na expressao que exclui a
  # coluna do schema efetivo, nao uma negacao explicita escrita em algum lugar.
}

# Financeiro: 'publico' + 'financeiro', nunca 'pii'.
resource "aws_lakeformation_permissions" "financeiro" {
  principal   = aws_iam_role.financeiro.arn
  permissions = ["SELECT"]

  lf_tag_policy {
    resource_type = "TABLE"
    expression {
      key    = aws_lakeformation_lf_tag.sensibilidade.key
      values = ["publico", "financeiro"]
    }
  }
}

# Lojista: coluna E linha na MESMA concessao — um data cells filter cobre as duas.
resource "aws_lakeformation_data_cells_filter" "lojista" {
  table_data {
    database_name    = "cadencia_lake"
    table_name       = "prata_pedidos"
    name             = "por-loja"
    table_catalog_id = data.aws_caller_identity.atual.account_id

    # 4 colunas, nenhuma delas pii nem financeiro.
    column_names = ["pedido_id", "loja_id", "valor_centavos", "status"]

    row_filter {
      # var.loja_id_do_principal e resolvida por lojista, fora deste modulo (ver a nota
      # de escala na secao 16 — um filtro por loja nao escala manualmente para centenas).
      filter_expression = "loja_id = '${var.loja_id_do_principal}'"
    }
  }
}

resource "aws_lakeformation_permissions" "lojista" {
  principal   = aws_iam_role.lojista.arn
  permissions = ["SELECT"]

  data_cells_filter {
    database_name    = "cadencia_lake"
    table_name       = "prata_pedidos"
    table_catalog_id = data.aws_caller_identity.atual.account_id
    name             = aws_lakeformation_data_cells_filter.lojista.table_data[0].name
  }
}

# iam-papeis.tf — tres papeis, a MESMA policy de metadado — quem decide coluna e linha e o LF

data "aws_iam_policy_document" "leitura_via_lf" {
  statement {
    effect = "Allow"
    actions = [
      "lakeformation:GetDataAccess",
      "glue:GetTable",
      "glue:GetDatabase",
      "glue:GetPartitions",
    ]
    resources = ["*"]
    # As 4 acoes SAO de metadado/sessao — nenhuma aceita ARN de tabela ou coluna. E o
    # Lake Formation, nao esta policy, quem decide QUAL coluna e QUAL linha a credencial
    # resultante consegue de fato ler. Reparar que os TRES papeis abaixo anexam a MESMA
    # policy e o ponto: o IAM nao diferencia Theo de Ana de Rita — quem diferencia e a tag.
  }
}

resource "aws_iam_role" "atendimento" {
  name               = "cadencia-atendimento"
  assume_role_policy = data.aws_iam_policy_document.assume_via_identity_center.json
}

resource "aws_iam_role" "financeiro" {
  name               = "cadencia-financeiro"
  assume_role_policy = data.aws_iam_policy_document.assume_via_identity_center.json
}

resource "aws_iam_role" "lojista" {
  name               = "cadencia-lojista"
  assume_role_policy = data.aws_iam_policy_document.assume_via_identity_center.json
}

resource "aws_iam_role_policy" "atendimento_lf" {
  role   = aws_iam_role.atendimento.id
  policy = data.aws_iam_policy_document.leitura_via_lf.json
}

resource "aws_iam_role_policy" "financeiro_lf" {
  role   = aws_iam_role.financeiro.id
  policy = data.aws_iam_policy_document.leitura_via_lf.json
}

resource "aws_iam_role_policy" "lojista_lf" {
  role   = aws_iam_role.lojista.id
  policy = data.aws_iam_policy_document.leitura_via_lf.json
}

# NENHUM destes tres papeis tem s3:GetObject nem glue:GetTable com Resource especifico
# de coluna — porque essa granularidade nao existe no vocabulario do IAM. Comparar com
# o L41 (IAM minimo por uso real): la, o principio e 'um papel por job, Resource
# especifico'; aqui, o Resource especifico simplesmente nao tem onde declarar coluna.

// TesteDeNegativa.cs — prova que a concessao nega de verdade, com numero

using Amazon.Athena;
using Amazon.Athena.Model;
using Amazon.SecurityToken;
using Amazon.SecurityToken.Model;

namespace Cadencia.Governanca;

public record PapelEsperado(string RoleArn, string Sessao, int ColunasEsperadas);

public sealed class TesteDeNegativa
{
    private const string Banco = "cadencia_lake";
    private const string ResultadoS3 = "s3://cadencia-lake/atenas-resultados/";

    // Os tres papeis e a contagem de coluna que CADA UM deveria ver — a contagem e a
    // prova, nao a ausencia de erro. 8 (atendimento), 9 (financeiro, com margem de
    // custo), 4 (lojista, so as colunas nao sensiveis, e so a propria loja).
    private static readonly PapelEsperado[] Papeis =
    [
        new("arn:aws:iam::111122223333:role/cadencia-atendimento", "teste-atendimento", 8),
        new("arn:aws:iam::111122223333:role/cadencia-financeiro", "teste-financeiro", 9),
        new("arn:aws:iam::111122223333:role/cadencia-lojista", "teste-lojista", 4),
    ];

    public async Task<bool> RodarAsync()
    {
        var tudoPassou = true;

        foreach (var papel in Papeis)
        {
            using var sts = new AmazonSecurityTokenServiceClient();
            var credencial = await sts.AssumeRoleAsync(new AssumeRoleRequest
            {
                RoleArn = papel.RoleArn,
                RoleSessionName = papel.Sessao,
            });

            using var athena = new AmazonAthenaClient(credencial.Credentials);

            // 1. SELECT * precisa devolver EXATAMENTE a contagem esperada — nem a mais
            //    (vazamento de coluna), nem a menos (bloqueio de coluna legitima).
            var colunas = await ContarColunasAsync(athena,
                $"SELECT * FROM {Banco}.prata_pedidos LIMIT 1");
            if (colunas != papel.ColunasEsperadas)
            {
                Console.WriteLine(
                    $"FALHOU: {papel.Sessao} viu {colunas} colunas, esperava {papel.ColunasEsperadas}");
                tudoPassou = false;
                continue;
            }

            // 2. A consulta EXPLICITA a uma coluna de PII precisa FALHAR — nao voltar
            //    vazia, nao voltar nula: falhar, com o erro do Lake Formation.
            var negouDeVerdade = await FalhaComPermissaoNegadaAsync(athena,
                $"SELECT cpf_cliente FROM {Banco}.prata_pedidos LIMIT 1");
            if (!negouDeVerdade)
            {
                Console.WriteLine($"FALHOU: {papel.Sessao} conseguiu ler cpf_cliente — a negativa nao nega");
                tudoPassou = false;
                continue;
            }

            Console.WriteLine($"OK: {papel.Sessao} — {colunas} colunas, negativa confirmada");
        }

        return tudoPassou;
    }

    private static async Task<int> ContarColunasAsync(AmazonAthenaClient athena, string sql)
    {
        var execucao = await athena.StartQueryExecutionAsync(new StartQueryExecutionRequest
        {
            QueryString = sql,
            QueryExecutionContext = new QueryExecutionContext { Database = Banco },
            ResultConfiguration = new ResultConfiguration { OutputLocation = ResultadoS3 },
        });
        await EsperarAsync(athena, execucao.QueryExecutionId);
        var resultado = await athena.GetQueryResultsAsync(
            new GetQueryResultsRequest { QueryExecutionId = execucao.QueryExecutionId, MaxResults = 1 });
        return resultado.ResultSet.ResultSetMetadata.ColumnInfo.Count;
    }

    private static async Task<bool> FalhaComPermissaoNegadaAsync(AmazonAthenaClient athena, string sql)
    {
        try
        {
            var execucao = await athena.StartQueryExecutionAsync(new StartQueryExecutionRequest
            {
                QueryString = sql,
                QueryExecutionContext = new QueryExecutionContext { Database = Banco },
                ResultConfiguration = new ResultConfiguration { OutputLocation = ResultadoS3 },
            });
            var estado = await EsperarAsync(athena, execucao.QueryExecutionId);
            // FAILED com mensagem de permissao do LF conta como negativa provada;
            // SUCCEEDED significa que a coluna vazou.
            return estado == QueryExecutionState.FAILED;
        }
        catch (AmazonAthenaException)
        {
            return true; // rejeitada antes mesmo de virar execucao — tambem conta como negativa
        }
    }

    private static async Task<QueryExecutionState> EsperarAsync(AmazonAthenaClient athena, string id)
    {
        while (true)
        {
            var status = await athena.GetQueryExecutionAsync(new GetQueryExecutionRequest { QueryExecutionId = id });
            var estado = status.QueryExecution.Status.State;
            if (estado is QueryExecutionState.SUCCEEDED or QueryExecutionState.FAILED or QueryExecutionState.CANCELLED)
                return estado;
            await Task.Delay(1000);
        }
    }
}

# provas.sh — cinco medicoes; nenhuma conclusao vem de "a consulta rodou sem erro"

BANCO=cadencia_lake

# ── Prova 1: a tabela fisica tem 12 colunas ──────────────────────────────────
aws glue get-table --database-name "$BANCO" --name prata_pedidos \
  --query 'length(Table.StorageDescriptor.Columns)'
# Esperado: 12

# ── Provas 2 a 4: schema efetivo por papel ───────────────────────────────────
for PAPEL in atendimento financeiro lojista; do
  CRED=$(aws sts assume-role --role-arn "arn:aws:iam::111122223333:role/cadencia-${PAPEL}" \
    --role-session-name "prova-${PAPEL}" --query 'Credentials' --output json)
  export AWS_ACCESS_KEY_ID=$(echo "$CRED" | jq -r .AccessKeyId)
  export AWS_SECRET_ACCESS_KEY=$(echo "$CRED" | jq -r .SecretAccessKey)
  export AWS_SESSION_TOKEN=$(echo "$CRED" | jq -r .SessionToken)

  ID=$(aws athena start-query-execution \
    --query-string "SELECT * FROM ${BANCO}.prata_pedidos LIMIT 1" \
    --query-execution-context Database="$BANCO" \
    --result-configuration OutputLocation=s3://cadencia-lake/atenas-resultados/ \
    --query 'QueryExecutionId' --output text)
  sleep 3
  echo "${PAPEL}: $(aws athena get-query-results --query-execution-id "$ID" \
    --query 'length(ResultSet.ResultSetMetadata.ColumnInfo)') colunas"
  unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
done
# Esperado: atendimento: 8 colunas / financeiro: 9 colunas / lojista: 4 colunas

# ── Prova 5: consulta explicita a coluna de PII, como atendimento, FALHA ─────
aws athena start-query-execution \
  --query-string "SELECT cpf_cliente FROM ${BANCO}.prata_pedidos LIMIT 1" \
  --query-execution-context Database="$BANCO" \
  --result-configuration OutputLocation=s3://cadencia-lake/atenas-resultados/
# Esperado: FAILED, com InsufficientLakeFormationPermissionsException na mensagem.

#!/usr/bin/env bash
# limpar.sh — o que o destroy nao leva, e o que e ACCOUNT-WIDE
set -euo pipefail

PROJETO="${PROJETO:?defina PROJETO}"

# 1. Derrube o que o Terraform administra (tags, concessoes, data filter, papeis IAM).
terraform destroy -auto-approve

# 2. ATENCAO: aws_lakeformation_data_lake_settings.admin e configuracao de CONTA — se
#    outro laboratorio ou processo tambem depende do Lake Formation estar ativo, NAO
#    remova o registro do Data Lake Location as cegas.
aws lakeformation describe-resource --resource-arn arn:aws:s3:::cadencia-lake \
  --query 'ResourceInfo.LastModified' --output text 2>/dev/null || echo 'ja removido'

# 3. Os DADOS em si: bronze e prata continuam no S3 do L62/L65. Este laboratorio nao os
#    apaga porque nao foi ele quem os criou.
aws s3 ls "s3://cadencia-lake/prata/pedidos/" --recursive --summarize | tail -2

# 4. Tags LF-TBAC: confira se sobrou associacao orfa numa coluna que voce testou a mao.
aws lakeformation list-lf-tags --query 'LFTags[].TagKey' --output table

# 5. Prova final: nada com o nome do projeto de pe fora do que era esperado.
aws resourcegroupstaggingapi get-resources \
  --tag-filters Key=Projeto,Values="${PROJETO}" \
  --query "ResourceTagMappingList[].ResourceARN" --output table