Crie uma REST API com Cloudflare Workers e MongoDB Atlas

Luke Edwards, Maxime Beugnet7 min read • Published Nov 15, 2021 • Updated Mar 29, 2024

Sem servidor Cloudflare Atlas TypeScript

APLICATIVO COMPLETO

Avalie esse Tutorial

Introdução

O Cloudflare Workers fornece um ambiente de execução sem servidor que permite criar aplicativos totalmente novos ou ampliar os existentes sem configurar ou manter a infraestrutura.

MongoDB Atlas permite criar, gerenciar e monitorar clusters do MongoDB no provedor de nuvem de sua escolha (AWS, GCP ou Azure) enquanto o Web SDK pode fornecer uma camada de autenticação e definir regras de acesso às coleções.

Nesta publicação no blog, combinaremos todas essas tecnologias e criaremos uma REST API com um worker da Cloudflare usando um MongoDB Atlas cluster para armazenar os dados.

Observação: neste tutorial, o worker não está usando nenhuma forma de cache. Embora a conexão entre o MongoDB e o aplicativo sem servidor do Atlas seja estabelecida e tratada automaticamente no backend do Atlas App Services, cada nova query enviada ao worker exige que o usuário passe pelo processo de autenticação e autorização antes de executar qualquer query. Neste tutorial, usamos chaves de API para lidar com esse processo, mas o Atlas App Services oferece muitos provedores de autenticação.

TL;DR!

O worker está neste repositório GitHub. O README explica tudo, se você souber o que está fazendo. Caso contrário, sugerimos que você siga esta publicação no blog passo a passo. ;-)

Trecho de código

Pré-requisitos

SEM cartão de crédito! Você pode executar todo esse tutorial gratuitamente!
Git e cURL.
Conta do MongoDB Atlas.
MongoDB Atlas Cluster (um cluster M0 gratuito é adequado).
Conta Cloudflare (plano gratuito é suficiente) com um subdomínio *.workers.dev para os trabalhadores. Siga as etapas 1 a 3 desta documentação para obter tudo o que você precisa.

Criaremos o aplicativo Atlas App Services (antes chamado de aplicativo MongoDB Realm) juntos na próxima seção. Isso fornecerá o AppID e a chave API de que precisamos.

Para implantar nosso worker da Cloudflare, precisamos:

O ID do aplicativo (canto superior esquerdo do seu aplicativo; consulte a próxima seção).
O login/senha da conta da Cloudflare.
O ID da conta da CloudFlare (na aba Workers > Visão geral).

Para testar (ou interagir com) a REST API, precisamos:

A chave API de autenticação (mais sobre isso abaixo, mas está na aba Autenticação > Chaves de API).
O subdomínio *.workers.dev da Cloudflare (na aba Trabalhadores > Visão geral).

Ele foi criado durante essa etapa de sua configuração:

Criar e configurar o aplicativo do Atlas

Para começar, vá para a página principal do MongoDB Atlas, onde você pode ver seu cluster e acessar a guia “App Services” na parte superior.

Crie um aplicativo vazio (sem modelo) o mais próximo possível do MongoDB Atlas cluster para evitar latência entre o cluster e o aplicativo. Meu aplicativo é "local" na Irlanda (eu-west-1) no meu caso.

Agora que nosso aplicativo foi criado, precisamos configurar duas coisas: autenticação por meio de API e regras da coleção. Antes disso, observe que você pode recuperar o ID do aplicativo no canto superior esquerdo do novo aplicativo.

Autenticação via chaves de API

Vá para Autenticação > Chaves de API.

Ative o provedor e salve o rascunho.

Precisamos criar uma chave de API, mas só podemos fazer isso se o provedor já estiver implantado. Clique em revisar e implantar.

Agora você pode criar uma chave de API e salvá-la em algum lugar! Ele será exibido apenas uma vez. Se você perdê-lo, descarte este e crie um novo.

Temos apenas um usuário em nosso aplicativo, pois criamos apenas uma única chave de API. Observe que este tutorial funcionaria com qualquer outro método de autenticação se você atualizasse o código de autenticação adequadamente no trabalhador.

Regras de coleção

Por padrão, seu aplicativo não pode acessar nenhuma coleção do MongoDB Atlas cluster. Para definir como os usuários podem interagir com os dados, você deve definir funções e permissões.

Em nosso caso, queremos criar uma REST API básica na qual cada usuário possa ler e gravar seus próprios dados em uma única coleção todos no banco de dadoscloudflare.

Vá para a aba Regras e vamos criar essa nova coleção cloudflare.todos.

Primeiro, clique em "criar uma coleção".

Em seguida, nomeie seu banco de dados cloudflare e a coleção todos. Clique em Criar!

Cada documento nesta coleção pertencerá a um usuário único definido pelo campo owner_id. Este campo conterá o ID do usuário que você pode ver na aba App Users.

Para limitar os usuários a apenas ler e gravar seus próprios dados, clique em sua nova coleção todos na IU de Regras. Adicione a regra readOwnWriteOwn no Other presets.

Depois de adicionar esta função predefinida, você pode verificar novamente a regra clicando em Advanced view. Deve conter o seguinte:

Trecho de código

Agora você pode clicar mais uma vez em Review Draft and Deploy. Nosso aplicativo agora está pronto para uso.

Configurar e implantar o trabalhador da Cloudflare

O worker Cloudflare está disponível no repositório GitHub. Vamos clonar o repositório.

Trecho de código

Agora que temos o modelo do worker, só precisamos alterar a configuração para implantá-lo em sua conta da Cloudflare.

Edite o arquivo wrangler.toml:

Substitua CLOUDFLARE_ACCOUNT_ID pelo ID real da sua conta Cloudflare.
Substitua MONGODB_ATLAS_APPID pelo seu ID real do aplicativo MongoDB Atlas App Services.

Agora você pode implantar seu worker na sua conta da Cloudflare usando o Wrangler:

Trecho de código

Acesse sua conta da Cloudflare. Agora você deve ver seu novo worker na aba Workers > Visão geral.

Confira o código da REST API

Antes de testarmos a API, dedique um momento para ler o código da REST API que acabamos de implantar, que está no arquivo src/index.ts:

Trecho de código

import * as Realm from 'realm-web';
import * as utils from './utils';

// The Worker's environment bindings. See `wrangler.toml` file.
interface Bindings {
    // MongoDB Atlas Application ID
    ATLAS_APPID: string;
}

// Define type alias; available via `realm-web`
type Document = globalThis.Realm.Services.MongoDB.Document;

// Declare the interface for a "todos" document
interface Todo extends Document {
    owner_id: string;
    done: boolean;
    todo: string;
}

let App: Realm.App;
const ObjectId = Realm.BSON.ObjectID;

// Define the Worker logic
const worker: ExportedHandler<Bindings> = {
    async fetch(req, env) {
        const url = new URL(req.url);
        App = App || new Realm.App(env.ATLAS_APPID);

const method = req.method;
        const path = url.pathname.replace(/[/]$/, '');
        const todoID = url.searchParams.get('id') || '';

if (path !== '/api/todos') {
            return utils.toError(`Unknown '${path}' URL; try '/api/todos' instead.`, 404);
        }

const token = req.headers.get('authorization');
        if (!token) return utils.toError(`Missing 'authorization' header; try to add the header 'authorization: ATLAS_APP_API_KEY'.`, 401);

try {
            const credentials = Realm.Credentials.apiKey(token);
            // Attempt to authenticate
            var user = await App.logIn(credentials);
            var client = user.mongoClient('mongodb-atlas');
        } catch (err) {
            return utils.toError('Error with authentication.', 500);
        }

// Grab a reference to the "cloudflare.todos" collection
        const collection = client.db('cloudflare').collection<Todo>('todos');

try {
            if (method === 'GET') {
                if (todoID) {
                    // GET /api/todos?id=XXX
                    return utils.reply(
                        await collection.findOne({
                            _id: new ObjectId(todoID)
                        })
                    );
                }

// GET /api/todos
                return utils.reply(
                    await collection.find()
                );
            }

// POST /api/todos
            if (method === 'POST') {
                const {todo} = await req.json();
                return utils.reply(
                    await collection.insertOne({
                        owner_id: user.id,
                        done: false,
                        todo: todo,
                    })
                );
            }

// PATCH /api/todos?id=XXX&done=true
            if (method === 'PATCH') {
                return utils.reply(
                    await collection.updateOne({
                        _id: new ObjectId(todoID)
                    }, {
                        $set: {
                            done: url.searchParams.get('done') === 'true'
                        }
                    })
                );
            }

// DELETE /api/todos?id=XXX
            if (method === 'DELETE') {
                return utils.reply(
                    await collection.deleteOne({
                        _id: new ObjectId(todoID)
                    })
                );
            }

// unknown method
            return utils.toError('Method not allowed.', 405);
        } catch (err) {
            const msg = (err as Error).message || 'Error with query.';
            return utils.toError(msg, 500);
        }
    }
}

// Export for discoverability
export default worker;

Testar a API REST

Agora que você está um pouco mais familiarizado com essa REST API, vamos testá-la!

Observe que decidimos passar os valores como parâmetros e a chave de API de autorização como um cabeçalho como este:

Trecho de código

Você pode usar o Postman ou qualquer outro para testar sua REST API, mas para facilitar, criei um script bash na pasta api_tests.

Para que funcionem, precisamos editar o arquivo api_tests/variables.sh e fornecer a eles:

URL do worker da Cloudflare: substitua YOUR_SUBDOMAIN, para que o URL final do worker corresponda ao seu.
A chave da API do MongoDB Atlas App Service: substitua YOUR_ATLAS_APP_AUTH_API_KEY por sua chave de API de autenticação.

Por fim, podemos executar todos os scripts assim, por exemplo:

Trecho de código

$ cd api_tests

$ ./post.sh "Write a good README.md for Github"
{
  "insertedId": "618615d879c8ad6d1129977d"
}

$ ./post.sh "Commit and push"
{
  "insertedId": "618615e479c8ad6d11299e12"
}

$ ./findAll.sh 
[
  {
    "_id": "618615d879c8ad6d1129977d",
    "owner_id": "6186154c79c8ad6d11294f60",
    "done": false,
    "todo": "Write a good README.md for Github"
  },
  {
    "_id": "618615e479c8ad6d11299e12",
    "owner_id": "6186154c79c8ad6d11294f60",
    "done": false,
    "todo": "Commit and push"
  }
]

$ ./findOne.sh 618615d879c8ad6d1129977d
{
  "_id": "618615d879c8ad6d1129977d",
  "owner_id": "6186154c79c8ad6d11294f60",
  "done": false,
  "todo": "Write a good README.md for Github"
}

$ ./patch.sh 618615d879c8ad6d1129977d true
{
  "matchedCount": 1,
  "modifiedCount": 1
}

$ ./findAll.sh 
[
  {
    "_id": "618615d879c8ad6d1129977d",
    "owner_id": "6186154c79c8ad6d11294f60",
    "done": true,
    "todo": "Write a good README.md for Github"
  },
  {
    "_id": "618615e479c8ad6d11299e12",
    "owner_id": "6186154c79c8ad6d11294f60",
    "done": false,
    "todo": "Commit and push"
  }
]

$ ./deleteOne.sh 618615d879c8ad6d1129977d
{
  "deletedCount": 1
}

$ ./findAll.sh 
[
  {
    "_id": "618615e479c8ad6d11299e12",
    "owner_id": "6186154c79c8ad6d11294f60",
    "done": false,
    "todo": "Commit and push"
  }
]

Como você pode ver, a REST API funciona perfeitamente!

Embrulhar

A Cloudflare oferece um produto Workers KV que pode facilitar uma combinação rápida com o Workers, mas ainda é um armazenamento simples de dados chave-valor e a maioria dos aplicativos vai superá-lo. Por outro lado, o MongoDB é um banco de dados poderoso e completo que desbloqueia a capacidade de armazenar, realizar query e indexar seus dados sem comprometer a segurança ou a escalabilidade do seu aplicativo.

Como demonstrado nesta publicação, é possível tirar o máximo proveito de ambas as tecnologias. Como resultado, construímos uma REST API poderosa e segura que será muito bem dimensionada.

Outra opção para se conectar à Cloudflare é a MongoDB Atlas Data API. A Atlas Data API oferece uma maneira leve de se conectar ao MongoDB Atlas que pode ser considerada semelhante a uma REST API. Para saber mais, veja este tutorial do meu colega consultor de desenvolvedores, Mark Smith!

Em caso de dúvidas, acesse nosso website da comunidade de desenvolvedores, no qual os engenheiros e a comunidade do MongoDB ajudam a criar sua próxima grande ideia com o MongoDB. Se sua pergunta for sobre a Cloudflare, recomendamos que você participe da comunidade ativa do Discord.

Avalie esse Tutorial

Relacionado

Tutorial

Previsão de pontuação de filmes com BigQuery, Vertex AI e MongoDB Atlas

Jul 11, 2023 | 11 min read

Tutorial

Aplicativos Web de última geração com Remix e MongoDB Atlas Data API

Aug 01, 2024 | 10 min read

Artigo

Uma REST API gratuita para o conjunto de dados COVID-19 da Johns Hopkins University

Aug 15, 2024 | 5 min read

Tutorial

Building an Advanced RAG System With Self-Querying Retrieval

Sep 12, 2024 | 21 min read

Sumário

Introdução
TL;DR!
Pré-requisitos
Criar e configurar o aplicativo do Atlas
Configurar e implantar o trabalhador da Cloudflare
Confira o código da REST API
Testar a API REST
Embrulhar