system:warrant@pt-BR

Ecossistema

Warrant

Um serviço de autorização inspirado no Zanzibar cujo repositório de código aberto está parado desde meados de 2024, depois que a WorkOS adquiriu a empresa e deu continuidade ao produto como WorkOS FGA.

Fatos verificados em Seções do artigo §2.1, §2.3.1, §2.4

Mantenedor
WorkOS (acquired 2024)
Licença
Apache-2.0
Linguagem
Go
Status
Inativo como código aberto; continua como WorkOS FGA
Versão mais recente
v1.15.1 (2024-06-10)
Repositório
github.com/warrant-dev/warrant
Documentação
workos.com/docs/fga

O Warrant é um serviço de autorização escrito em Go. Seu README descreve “a relationship based access control (ReBAC) engine (inspired by Google Zanzibar)” (um mecanismo de controle de acesso baseado em relacionamentos (ReBAC), inspirado no Google Zanzibar) que também cobre regras baseadas em papéis e em atributos, e escreve um relacionamento como [user:1] is an [editor] of [document:docA] (README). Um relacionamento armazenado é chamado de warrant.

A WorkOS adquiriu o Warrant em 2024. A data, 2024-04-23, vem de uma publicação da WorkOS no X (publicação): o X não serviu a página ao verificador deste site, então a data foi decodificada a partir do ID da publicação, e o texto da publicação (“Today, we are excited to announce the acquisition of @warrant_dev”, hoje temos o prazer de anunciar a aquisição do @warrant_dev) foi visto apenas em um resultado de busca. Nenhuma publicação de blog da própria WorkOS foi encontrada. O site do Warrant agora diz “Warrant —> Now WorkOS FGA” (warrant.dev), e o README aponta para a documentação do WorkOS FGA.

O artigo e o Warrant lado a lado

O site de documentação do Warrant não existe mais, então esta tabela foi montada a partir do código aberto.

No artigo No Warrant (código aberto)
Configuração de namespace (§2.3) Um tipo de objeto: JSON com type e relations, sendo cada relação uma regra (spec.go)
Tupla de relação object#relation@user (§2.1) Um warrant: objectType, objectId, relation e um subject com objectType, objectId e uma relation opcional
_this Warrants diretos, que uma verificação sempre tenta primeiro (“1. Check for direct warrant match”, 1. procurar correspondência com um warrant direto, check/service.go)
computed_userset { "inheritIf": "owner" }
tuple_to_userset { "inheritIf": "viewer", "ofType": "folder", "withRelation": "parent" }
União, interseção, exclusão inheritIf definido como anyOf, allOf ou noneOf, com rules aninhadas
Zookie (§2.2, §2.4) O cabeçalho Warrant-Token; o servidor de código aberto age apenas sobre o valor latest (ver Consistência) (wookie.go)
Check (§2.4.4) POST /v2/check (também /v2/authorize)
Read (§2.4.1) GET /v2/warrants; GET /v2/query para consultas sobre o grafo
Write (§2.4.2) POST /v2/warrants, DELETE /v2/warrants
Watch (§2.4.3) Nenhum
Expand (§2.4.5) Nenhum
Leopard (§3.2.4) Nenhum
Spanner (§3.1) MySQL, PostgreSQL ou SQLite, com uma réplica de leitura opcional

O exemplo recorrente como tipos de objeto

A Figura 1 do artigo torna os donos editores, os editores visualizadores, e os visualizadores da pasta pai visualizadores do documento (§2.3.1). No Warrant, cada tipo de objeto lista suas relações; um objeto vazio {} significa “apenas warrants diretos”, e inheritIf acrescenta uma regra.

[
  { "type": "group", "relations": { "member": {} } },
  { "type": "folder", "relations": { "viewer": {} } },
  {
    "type": "doc",
    "relations": {
      "parent": {},
      "owner": {},
      "editor": { "inheritIf": "owner" },
      "viewer": {
        "inheritIf": "anyOf",
        "rules": [
          { "inheritIf": "editor" },
          { "inheritIf": "viewer", "ofType": "folder", "withRelation": "parent" }
        ]
      }
    }
  }
]

Não há entrada user: o servidor cria um tipo de objeto user embutido em sua migração inicial do banco de dados (migração). A regra com ofType e withRelation encontra os warrants doc:readme#parent@folder:… e verifica viewer em cada pasta encontrada, como no código de verificação (getMatchingSubjectsBySubjectType em check/service.go).

Os cinco warrants do exemplo recorrente, como corpos de POST /v2/warrants:

{ "objectType": "doc", "objectId": "readme", "relation": "owner", "subject": { "objectType": "user", "objectId": "anne" } }
{ "objectType": "group", "objectId": "eng", "relation": "member", "subject": { "objectType": "user", "objectId": "beto" } }
{ "objectType": "doc", "objectId": "readme", "relation": "viewer", "subject": { "objectType": "group", "objectId": "eng", "relation": "member" } }
{ "objectType": "doc", "objectId": "readme", "relation": "parent", "subject": { "objectType": "folder", "objectId": "A" } }
{ "objectType": "folder", "objectId": "A", "relation": "viewer", "subject": { "objectType": "user", "objectId": "chen" } }

Qual warrant e qual regra decidem a relação viewer de cada pessoa com o readme?

O exemplo recorrente como warrants do WarrantCinco warrants. O user anne é owner do doc readme. O user beto é member do group eng. group eng#member é viewer do doc readme. A folder A é parent do doc readme. O user chen é viewer da folder A. O caminho de Chen pela folder A está destacado: ele é resolvido pela regra com ofType folder e withRelation parent.user:anneuser:betouser:chengroup:engfolder:Adoc:readmeownermemberviewer (#member)viewerparent
Anne: owner → editor → viewer por inheritIf. Beto: um warrant cujo sujeito é group:eng#member. Chen: a regra ofType/withRelation. Tracejado: um sujeito com relação.

Arquitetura

Qual banco de dados responde a uma requisição?

Implantação do Warrant, a partir do código abertoO seu serviço chama um único serviço HTTP do Warrant. As escritas, e as leituras que carregam Warrant-Token latest, vão para o banco de dados SQL primário. As demais leituras vão para o pool de leitura quando um DSN de leitura está configurado.Seu serviçoServiço HTTPWarrantBanco primárioBanco de leitura(opcional)/v2/check, /v2/warrantsescritas, latestoutras leituras
Amarelo: o serviço Warrant. Verde: bancos de dados. Azul: o chamador. Tracejado: usado apenas quando um DSN de leitura está definido.
  • Um único serviço Go serve a API HTTP (router.go).
  • As configurações de MySQL e PostgreSQL recebem um dsn e um readerDsn opcional (config.go); o SQLite também é suportado, “in-memory or file” (em memória ou em arquivo) (README).
  • A regra para escolher um pool é um comentário em sql.go: usar o pool de escrita se a chamada for uma escrita, se não houver leitor, se o contexto “contains ‘latest’ wookie” (contém o wookie ‘latest’) ou se o código dentro do servidor tiver definido uma substituição pelo pool de escrita; caso contrário, usar o pool de leitura.

Consistência

O código do Warrant chama seu token de wookie (wookie). Um tipo Token contém um ID, uma versão e um timestamp, mas o servidor de código aberto nunca envia um ao cliente: o serviço de warrants retorna nil nessa posição e os handlers HTTP o ignoram (warrant/service.go, warrant/handlers.go). O que o servidor de fato lê é o cabeçalho de requisição Warrant-Token, e apenas um valor altera o comportamento: latest.

O que Warrant-Token: latest muda para uma verificação logo após uma escrita?

Warrant-Token: latestO serviço escreve o warrant doc:readme viewer group:eng#member; ele vai para o banco de dados primário. Uma verificação sem o cabeçalho é lida do banco de leitura. Uma verificação com Warrant-Token latest é lida do banco primário, que já contém a escrita.tempoSeu serviçoWarrantBanco primárioBanco de leituraPOST/v2/warrantswarrantescritoverificaçãosem cabeçalholido do poolde leituraverificaçãocom latestlido doprimário
O zookie do artigo nomeia um snapshot (§2.4); latest apenas nomeia um banco de dados.

O próprio README diz que baixa latência com alta vazão “requires running Warrant as a distributed service with the use of Warrant-Tokens (also referred to as Zookies in Google Zanzibar)” (exige executar o Warrant como um serviço distribuído com o uso de Warrant-Tokens, também chamados de Zookies no Google Zanzibar), e que “this open source version of Warrant is only capable of handling low-to-moderate throughput” (esta versão de código aberto do Warrant só é capaz de lidar com vazão baixa a moderada) (README, de autoria do fornecedor). Seu link sobre Warrant-Tokens agora leva à visão geral do WorkOS FGA, que não os descreve.

Observe a diferença em relação ao artigo. Um zookie define um limite inferior, o que permite ao Zanzibar “to choose any timestamp fresher than the one encoded in a zookie” (escolher qualquer timestamp mais atual do que o codificado em um zookie) e servir a maioria das verificações “at a default staleness with already replicated data” (com uma defasagem padrão, usando dados já replicados) (§2.2). latest não contém nenhum ponto no tempo: ele desloca a leitura para o primário, que é a cópia mais atual, mas abre mão da réplica.

Diferenças em relação ao artigo

  • Sem tokens de snapshot no servidor de código aberto, como visto acima.
  • RBAC e ABAC embutidos. Tipos de objeto embutidos para papéis, permissões, tenants, faixas de preço e funcionalidades, e condições de política sobre warrants (README, migração).
  • Uma linguagem de consulta. GET /v2/query responde a perguntas de listagem que o Read e o Expand do artigo não respondem (handlers de consulta).
  • Sem Watch, Expand ou Leopard, e um único primário SQL em vez do Spanner (§3.1).

Situação

  • Código aberto: primeira versão v0.1.0 em 2023-02-23; última versão v1.15.1 em 2024-06-10; último commit em 2025-12-05, uma alteração no README; não arquivado; cerca de 1,3 mil estrelas (versões, API do GitHub, 2026-11-13).
  • Empresa: adquirida pela WorkOS, anúncio no X em 2024-04-23 (ver acima; a publicação em si não pôde ser carregada).
  • Produto: WorkOS FGA. Sua documentação atual não menciona o Warrant nem o Zanzibar. Ela apresenta o FGA como uma extensão do RBAC da WorkOS: “You configure resource types in the WorkOS Dashboard” (você configura os tipos de recurso no WorkOS Dashboard), e o FGA “can be adopted incrementally, with no data migration or confusing schema DSL” (pode ser adotado de forma incremental, sem migração de dados nem uma DSL de schema confusa) (documentação do WorkOS FGA, de autoria do fornecedor). O JSON de tipos de objeto desta página é o formato do código aberto, não o do WorkOS FGA.

Fontes