Autentique requisições com Functions

Proteja um bucket do Object Storage com uma função que valida um JSON Web Token e entrega o objeto somente a uma requisição autorizada.

Última atualização

Ver como Markdown Configurar agente

Você pode colocar uma função na frente de um bucket do Object Storage, para que a função valide um JSON Web Token antes que qualquer objeto saia do bucket.

Uma requisição que carrega um token válido recebe o objeto com o seu content type. Toda outra requisição recebe HTTP 401 e o bucket nunca é lido. Um bucket que não precisa de token é servido por um connector e por uma regra do Rules Engine, o que Use um bucket como origem de uma aplicação cobre.

Pré-requisitos

  • Uma conta Azion.
  • A Azion CLI instalada e autorizada.
  • Node.js versão 18 ou superior.
  • Um bucket que guarda os objetos a proteger, com Workloads Access definido como Read Only ou Read & Write. Um bucket definido como Restricted não é lido por Azion Runtime, então a função não alcança nada nele. Consulte Criar um bucket.
  • Um secret de assinatura para os tokens que a sua aplicação emite.

Como a verificação funciona

A função responde às requisições que uma regra roteia para ela. Ela lê o token do header Authorization ou do cookie auth_token, verifica a assinatura contra o secret compartilhado e chama Object Storage somente depois que a assinatura confere. Um bucket também é alcançável pelo endpoint S3 e por um connector, e nenhum desses caminhos pede um token; a função protege o caminho em que ela está.

O fluxo abaixo mostra as duas recusas e a única rota que alcança o bucket:

Crie o projeto da função

A Azion CLI cria a estrutura do projeto e o npm adiciona a biblioteca que verifica o token. Para configurar o projeto:

Inicialize o projeto
azion init my-auth-storage

Nos prompts, defina Template como JavaScript e Runtime como Azion Runtime. A Azion CLI escreve o projeto em uma pasta my-auth-storage.

Vá para a pasta do projeto
cd my-auth-storage
Instale a biblioteca de tokens
npm install jose

A biblioteca jose verifica JSON Web Tokens em runtimes JavaScript. O npm a adiciona ao package.json.

A pasta do projeto guarda o código do template e a dependência jose.

Escreva o handler

Abra o arquivo JavaScript principal do projeto e substitua o conteúdo dele por este handler:

JavaScript
01import Storage from "azion:storage";
02import { jwtVerify } from "jose";
03
04async function verifyToken(token) {
05 try {
06 const secretKey = new TextEncoder().encode(Azion.env.get("JWT_SECRET"));
07 const { payload } = await jwtVerify(token, secretKey);
08 return { valid: true, payload };
09 } catch (error) {
10 console.error("JWT verification failed:", error.message);
11 return { valid: false, error: error.message };
12 }
13}
14
15function extractToken(request) {
16 // The Authorization header comes first.
17 const authHeader = request.headers.get("Authorization");
18 if (authHeader && authHeader.startsWith("Bearer ")) {
19 return authHeader.substring(7);
20 }
21
22 // The cookie is the fallback.
23 const cookieHeader = request.headers.get("Cookie");
24 if (cookieHeader) {
25 const cookies = cookieHeader.split(";").map(c => c.trim());
26 const authCookie = cookies.find(c => c.startsWith("auth_token="));
27 if (authCookie) {
28 return authCookie.substring(11);
29 }
30 }
31
32 return null;
33}
34
35async function handleRequest(event) {
36 const request = event.request;
37 const url = new URL(request.url);
38
39 // /files/image.png reaches the bucket as the key image.png
40 const objectKey = url.pathname.replace(/^\/files\//, "");
41
42 if (!objectKey) {
43 return new Response(JSON.stringify({ error: "Object key required" }), {
44 status: 400,
45 headers: { "Content-Type": "application/json" }
46 });
47 }
48
49 const token = extractToken(request);
50
51 if (!token) {
52 return new Response(JSON.stringify({
53 error: "Authentication required",
54 message: "Provide a valid JWT token in Authorization header or auth_token cookie"
55 }), {
56 status: 401,
57 headers: {
58 "Content-Type": "application/json",
59 "WWW-Authenticate": "Bearer"
60 }
61 });
62 }
63
64 const verification = await verifyToken(token);
65
66 if (!verification.valid) {
67 return new Response(JSON.stringify({
68 error: "Invalid token",
69 message: verification.error
70 }), {
71 status: 401,
72 headers: { "Content-Type": "application/json" }
73 });
74 }
75
76 try {
77 const storage = new Storage(Azion.env.get("BUCKET_NAME"));
78 const storageObject = await storage.get(objectKey);
79
80 return new Response(storageObject.content, {
81 status: 200,
82 headers: {
83 "Content-Type": storageObject.contentType || "application/octet-stream",
84 "Content-Length": String(storageObject.contentLength ?? ""),
85 "Cache-Control": "private, max-age=3600"
86 }
87 });
88 } catch (error) {
89 console.error("Storage error:", error);
90
91 if (error.message && error.message.includes("not found")) {
92 return new Response(JSON.stringify({
93 error: "Object not found"
94 }), {
95 status: 404,
96 headers: { "Content-Type": "application/json" }
97 });
98 }
99
100 return new Response(JSON.stringify({
101 error: "Internal server error"
102 }), {
103 status: 500,
104 headers: { "Content-Type": "application/json" }
105 });
106 }
107}
108
109addEventListener("fetch", (event) => {
110 event.respondWith(handleRequest(event));
111});

Seis decisões estão no código:

  • A key do objeto é o caminho da requisição com /files/ removido, então /files/image.png lê a key image.png. Uma requisição que deixa a key vazia retorna 400 com o corpo {"error": "Object key required"}.
  • Uma requisição sem token retorna 401, carrega o header WWW-Authenticate: Bearer e nomeia os dois lugares aceitos no seu campo message.
  • Um token que o secret não verifica retorna 401 com o corpo {"error": "Invalid token"} e a mensagem que jose levantou.
  • Um token verificado lê o objeto e o retorna com o content type que Object Storage armazenou, ou application/octet-stream quando o objeto não carrega nenhum. Cache-Control: private, max-age=3600 mantém a resposta fora de um cache compartilhado.
  • Uma key que não está no bucket retorna 404 com o corpo {"error": "Object not found"}. Toda outra falha de armazenamento retorna 500.
  • console.error escreve JWT verification failed: e Storage error:, e as duas linhas chegam aos logs da função.

O handler lê JWT_SECRET e BUCKET_NAME com Azion.env.get, então nenhum dos dois valores é escrito no código.

Configure as variáveis de ambiente

Crie um arquivo .env na raiz do projeto, com o bucket que o handler lê e o secret contra o qual ele verifica:

Texto
01BUCKET_NAME=your-bucket-name
02JWT_SECRET=your-secret

Configure o storage local para desenvolvimento

Azion Runtime responde a uma chamada local ao Object Storage a partir de uma pasta na sua máquina. Adicione um bloco storage ao azion.config para que storage.get resolva enquanto você desenvolve:

JavaScript
01storage: [
02 {
03 name: 'your-bucket-name',
04 prefix: 'your-bucket-prefix',
05 dir: './path/to/storage/files',
06 workloadsAccess: 'read_only',
07 },
08],

Substitua your-bucket-name, your-bucket-prefix e ./path/to/storage/files pelos valores do seu projeto. workloadsAccess é a grafia em camelCase que o arquivo de configuração usa para o nível de acesso do bucket, e read_only é suficiente para um handler que apenas lê.

Faça o deploy da função

O deploy envia o código e azion sync envia os valores que o código lê. Para colocar os dois na sua conta:

Faça o deploy do projeto
azion deploy

A Azion CLI faz o build do projeto e envia a função para a sua conta.

Envie as variáveis de ambiente
azion sync

O handler lê BUCKET_NAME e JWT_SECRET em tempo de execução. Sem este passo, as variáveis existem apenas no seu arquivo .env e a função não as encontra.

A função roda na sua conta com o nome do bucket e o secret de assinatura de que ela precisa.

Verifique a configuração

Assine um token com o mesmo secret, depois requisite um objeto três vezes: com o header, com o cookie e sem nenhum dos dois. Para verificar a função:

Assine um token de teste

Salve o script como sign-token.mjs na pasta do projeto, para que o Node.js o leia como um módulo, e rode com node sign-token.mjs:

JavaScript
01import { SignJWT } from 'jose';
02
03const secret = new TextEncoder().encode('your-secret-key');
04
05const token = await new SignJWT({
06 sub: 'user123',
07 permissions: ['read:files']
08})
09 .setProtectedHeader({ alg: 'HS256' })
10 .setIssuedAt()
11 .setExpirationTime('2h')
12 .sign(secret);
13
14console.log(token);

O script imprime o token assinado. Defina secret com o valor que você armazenou em JWT_SECRET, ou a função recusa todo token que o script emite.

Requisite um objeto com o header Authorization
Shell
01curl -H "Authorization: Bearer YOUR_JWT_TOKEN" \
02 https://your-domain.com/files/document.pdf

A resposta carrega o objeto e o content type que Object Storage armazenou para ele.

Requisite o mesmo objeto com o cookie
Shell
01curl -b "auth_token=YOUR_JWT_TOKEN" \
02 https://your-domain.com/files/document.pdf

A resposta é a mesma, o que confirma o fallback do cookie.

Requisite o objeto sem token
curl https://your-domain.com/files/document.pdf

A função recusa a requisição com HTTP 401:

JSON
01{
02 "error": "Authentication required",
03 "message": "Provide a valid JWT token in Authorization header or auth_token cookie"
04}

Um token assinado retorna o objeto, e um token ausente ou não verificável retorna 401 sem alcançar o bucket.

Próximos passos

Criar um bucketCrie o bucket que esta função lê e defina o seu nível de acesso.Use um bucket como origem de uma aplicaçãoSirva um bucket por um connector e uma regra quando os objetos não precisam de token.API de runtime do StorageTodos os métodos e campos do módulo azion:storage que o handler chama.FunctionsComo uma função é construída, implantada e roteada na Azion Platform.