Início / coding / Perguntas / 79597535
Accepted
yazandaoudd
Asked: 2025-04-29 10:48:26 +0800 CST

Como posso autenticar solicitações de front-end para um gateway de API personalizado usando sessões Appwrite em vez de JWTs?

  • 772

Estou desenvolvendo um aplicativo móvel full-stack usando o Appwrite para autenticação e serviços de back-end. O front-end se comunica com um gateway de API personalizado que envia solicitações para vários microsserviços.

Atualmente, estou usando a função account.createJWT() do Appwrite para autenticar usuários, mas os tokens JWT expiram a cada 15 minutos. Atualizar tokens com tanta frequência não é escalável para o meu aplicativo, especialmente com o crescimento da base de usuários. Por isso, estou tentando migrar para a validação de sessão em vez de JWTs.

O problema que estou enfrentando é: como autenticar corretamente as solicitações de front-end para meu gateway de API usando sessões do Appwrite?

Detalhes do ambiente:

Backend API gateway is built with FastAPI

Appwrite version: cloud

Frontend framework: React Native

Minhas perguntas são:

What is the correct way to validate Appwrite user sessions from a backend service (API gateway) without using the frontend SDKs?

Is it possible to securely authenticate frontend requests to a custom backend using only Appwrite sessions (without using short-lived JWTs)?

If not, what would be the best scalable approach for authenticating requests in this setup?

Qualquer conselho, fluxo recomendado ou exemplos seriam muito apreciados!

Aqui está o que eu tentei:

I retrieve the user session on the frontend (account.get() gives me session info).

I send the session ID (or the Appwrite cookie) along with API requests to my gateway.

On the backend (in the API gateway), I try to validate the session by using the Appwrite Server SDK (account.getSession(sessionId)).

However, sometimes I get errors like:
Unauthorized: User is missing "account" scope.
authentication

1 respostas

  1. Best Answer

    como validar sessões de usuário do appwrite no backend sem usar SDKs do frontend?

    você está quase lá. usar o SDK do servidor e chamar account.getSession(sessionId)é tecnicamente correto, mas o appwrite espera que o ID da sessão esteja vinculado a um cookie real na solicitação (como o cookie de sessão a_session_<projectid>).
    apenas chamar getSession(sessionId)o lado do servidor sem esse cookie às vezes não parece "natural" para o appwrite, e então ele grita "não autorizado"

    a maneira super limpa seria:

    • do seu frontend, envie o cookie de sessão junto com suas solicitações de API (assim como o comportamento do navegador)

    • no seu gateway fastapi, você escolhe esse cookie da solicitação

    • então, em vez de fazer getSession(sessionId), você faz account.get()ao enviar o cookie nos cabeçalhos de solicitação (o que significa que você tem que simular uma solicitação de usuário real)

    O problema é que o SDK do servidor appwrite não permite facilmente o envio manual de cookies brutos porque ele foi feito para chamadas "confiáveis ​​do lado do servidor",
    então a solução alternativa é:

    • faça chamadas REST diretas para a API HTTP do appwrite dentro do seu gateway em vez de usar o SDK

    • envie o cookie de sessão junto com os cabeçalhos de solicitação manualmente

    • exemplo: chamar GET https://[appwrite-endpoint]/v1/accountcom o X-Fallback-Cookiescabeçalho ou apenas encaminhar o cookie corretamente

    é possível autenticar com segurança frontend -> backend personalizado -> appwrite usando apenas sessões?

    Sim, é possível. Na verdade, é a maneira ideal e tradicional de "autenticação baseada em sessão".

    o fluxo seria:

    1. O frontend efetua login normalmente usando appwrite sdk → obtém a sessão

    2. O frontend armazena o cookie de sessão (automático se você estiver usando um navegador / para React Native você tem que fazer isso manualmente)

    3. O frontend envia solicitações para o seu gateway de API, carregando o cookie de sessão

    4. seu gateway extrai o cookie de sessão, valida a sessão (como eu disse acima, direciona a chamada REST para o /accountendpoint do appwrite)

    5. se appwrite disser que o usuário é bom, permita a solicitação aos microsserviços

    você nunca precisa do jwt dessa forma, a menos que queira escalabilidade entre vários clusters ou coisas do tipo SSO móvel + web mais tarde

    qual a melhor abordagem escalável se a sessão estiver confusa?

    se um dia esse modo de sessão parecer irritante (como se o gerenciamento de cookies no celular se tornasse doloroso),
    então você terá que migrar para um modelo híbrido:

    • tokens de acesso de curta duração (como 15 minutos)

    • tokens de atualização (de longa duração, tipo 1 mês)

    • problemas de backend

    • O frontend atualiza automaticamente o token de acesso sem que o usuário saiba

    mas, cara, falando sério, a menos que você esteja escalando loucamente (tipo milhões de usuários simultâneos),
    a autenticação de sessão é limpa, mais simples e você pode escalá-la horizontalmente usando sessões persistentes ou armazenamento de sessão do Redis, se necessário.

    versão rápida e rápida do fluxo certo que você pode tentar agora mesmo

    1. O frontend salva e envia o cookie de sessão manualmente

    2. fastapi obtém cookie, chama https://cloud.appwrite.io/v1/account(com cabeçalho de cookie) dentro de um simples requests.get()(biblioteca de requisições do python)

    3. se 200 ok → usuário é válido

    4. anexar informações do usuário para solicitar contexto e encaminhá-las aos microsserviços

    não precisa de jwt, não precisa atualizar a sessão, sem drama

    • -2

relate perguntas