O que é uma infraestrutura de backend?

Escolher a infraestrutura de backend adequada é crucial ao projetar seu backend. Isso pode impactar o desempenho, a flexibilidade e a capacidade de manutenção do seu backend, entre outros aspectos.

Neste artigo, explicaremos o que é uma infraestrutura de backend, exploraremos diferentes tipos de infraestruturas de backend e discutiremos os fatores essenciais a serem considerados ao tomar sua decisão.

Além disso, veremos como criar uma infraestrutura de backend usando o Back4app.

Objetivos

Ao final deste artigo, você será capaz de:

• Explicar o que é uma infraestrutura de backend
• Discutir os diferentes tipos de infraestruturas de backend (incluindo IaaS, PaaS e BaaS)
• Escolher a infraestrutura de backend adequada para o seu projeto
• Construir seu próprio backend utilizando o Back4App

O que é uma infraestrutura de backend?

A infraestrutura de backend é a combinação de componentes de software e hardware que suportam um sistema de backend. Isso inclui servidores, containers, componentes de rede, firewall e outros recursos.

A infraestrutura de backend é responsável por alta disponibilidade, escalabilidade, balanceamento de carga, segurança, roteamento, entre outros.

A infraestrutura de backend precisa ser projetada de forma a oferecer uma experiência de usuário sem interrupções.

O que considerar ao escolher uma infraestrutura de backend?

Velocidade

A velocidade é uma das características críticas de uma infraestrutura de backend. Os usuários esperam que o aplicativo funcione de maneira fluida e, por isso, é necessário otimizar a comunicação entre o lado do cliente e o backend.

Para mitigar a percepção de atrasos na comunicação, você pode usar alguns truques inteligentes. Por exemplo, implementar telas de carregamento, barras de progresso e exibir dicas e truques na interface do usuário.

Além disso, a velocidade é um dos fatores mais importantes no SEO, pois afeta a experiência do usuário e o desempenho da aplicação nos motores de busca.

Flexibilidade

A flexibilidade refere-se à capacidade da infraestrutura de backend de suportar várias linguagens de programação, frameworks e outras tecnologias (como bancos de dados).

Ao escolher uma infraestrutura de backend, certifique-se de optar por algo que ofereça suporte a uma ampla gama de tecnologias, garantindo que seu projeto possa crescer e adaptar-se conforme necessário.

Escalabilidade

A escalabilidade é um aspecto que deve ser considerado desde o início do desenvolvimento do seu aplicativo.

Pense em como o aplicativo será utilizado: você terá um número constante de usuários ou enfrentará picos de tráfego em determinados momentos?

Sua infraestrutura de backend precisa ser projetada para acomodar grandes cargas de trabalho. Para minimizar as despesas com servidores, as instâncias de sua aplicação devem ser criadas e destruídas conforme a demanda.

Manutenibilidade

Desenvolver e publicar seu aplicativo representa apenas 80% do trabalho. Depois disso, você precisará investir bastante tempo na manutenção da aplicação. Atualizar o software do servidor e aplicar patches de segurança deve ser o mais simples possível.

Escolha uma infraestrutura de backend com um sistema CI/CD integrado ou implemente o seu próprio, para facilitar o processo de manutenção e atualização contínua.

Requisitos de DevOps

Alguns tipos de infraestrutura de backend são mais complexos de usar. Escolha uma infraestrutura que você tenha tempo e recursos para gerenciar.

Se optar por uma infraestrutura de nível mais baixo, como IaaS, será necessário ter uma equipe especializada de DevOps para gerenciá-la.

Segurança

Você é totalmente responsável por manter os dados dos seus usuários seguros. Com o aumento dos ataques cibernéticos, é fundamental garantir que sua infraestrutura de backend siga os padrões de segurança mais recentes.

Use senhas fortes e geradas automaticamente, configure firewalls, evite executar software não confiável em seus servidores e realize verificações de segurança regularmente.

Esses fatores ajudarão a garantir que você escolha a infraestrutura de backend mais adequada para seu projeto, garantindo desempenho, segurança e escalabilidade adequados.

Tipos de Infraestruturas de Backend

Você pode utilizar seus próprios servidores (a chamada infraestrutura tradicional) ou aproveitar a infraestrutura em nuvem para implantar seu backend.

Na última década, muitas empresas migraram para modelos baseados em nuvem, pois isso permite economizar tempo e dinheiro.

Vamos analisar alguns dos modelos mais populares:

Infraestrutura como Serviço (IaaS)

A Infraestrutura como Serviço (IaaS) é o modelo de computação em nuvem menos abstrato.

Nesse modelo, o fornecedor de nuvem oferece recursos de computação em um ambiente virtualizado, como servidores, armazenamento, sistemas operacionais e componentes de rede.

O IaaS existe desde 2010 e continua sendo o modelo de computação em nuvem mais popular. Suas vantagens incluem alta escalabilidade, grande nível de controle e eficiência de custos.

Por outro lado, as desvantagens são a gestão mais complexa e os custos de manutenção mais elevados em comparação com outros modelos de nuvem.

Alguns dos fornecedores populares de IaaS são:

• Google Cloud Platform (GCP)
• Amazon Web Services (AWS)
• Microsoft Azure

Plataforma como Serviço (PaaS)

A Plataforma como Serviço (PaaS) é um modelo de computação em nuvem que oferece um ambiente fácil de usar para desenvolvimento, gestão e entrega de aplicações.

Inclui diversas ferramentas integradas de desenvolvimento de aplicativos, facilitando a criação e lançamento do seu app.

O PaaS simplifica a gestão da infraestrutura, proporcionando uma entrada mais rápida no mercado, maior segurança, economia de custos, escalabilidade, alta disponibilidade e redução na necessidade de codificação.

No entanto, pode limitar a flexibilidade e controle, além de apresentar riscos de dependência do fornecedor (vendor lock-in).

Exemplos de soluções PaaS incluem:

• Render
• Heroku
• Fly.io

Backend como Serviço (BaaS)

O Backend como Serviço (BaaS) automatiza o desenvolvimento do lado do servidor e a gestão da infraestrutura em nuvem.

Oferece bancos de dados em tempo real, gerenciamento de usuários, autenticação, notificações, integrações com redes sociais e muito mais.

O BaaS libera os desenvolvedores das preocupações com o backend, permitindo que se concentrem no frontend e nas necessidades de negócio.

Ele combina os benefícios do IaaS e do PaaS com a abstração do backend, resultando em um tempo mais rápido de lançamento no mercado e redução de custos.

As desvantagens incluem a falta de controle, o risco de dependência do fornecedor e, em alguns casos, custos relativamente altos.

Minhas plataformas BaaS favoritas são:

• Back4app
• Firebase
• Backendless

Containers como Serviço (CaaS)

O Containers como Serviço (CaaS) é um modelo de computação em nuvem que permite fazer upload, construir, escalar e gerenciar containers.

O CaaS geralmente inclui um runtime de container, registro de containers, funcionalidade de escalonamento automático, sistema CI/CD embutido, balanceamento de carga, entre outros!

O CaaS simplifica o gerenciamento de containers, removendo preocupações com a infraestrutura subjacente.

Ele incentiva o desenvolvimento ágil, facilita a arquitetura de microsserviços e acelera a criação de aplicações altamente escaláveis.

Plataformas de CaaS incluem:

• Back4app Containers
• Amazon Elastic Container Service
• Google Cloud Kubernetes

Esses modelos oferecem uma gama de opções dependendo do nível de controle, flexibilidade e esforço de gerenciamento que você deseja, permitindo que você escolha o mais adequado para suas necessidades de backend.

Como criar uma infraestrutura de backend?

Nesta parte do artigo, vamos criar uma infraestrutura de backend usando o Back4App.

O que é o Back4App?

O Back4App é uma plataforma de Backend como Serviço (BaaS) excepcional, que permite a criação rápida de backends para aplicativos web e móveis.

A plataforma é construída com tecnologias de código aberto e oferece uma vasta gama de funcionalidades.

Entre seus principais recursos estão:

• Bancos de dados com interface semelhante a planilhas
• Armazenamento de arquivos
• Gerenciamento de usuários e autenticação
• APIs auto-geradas (REST e GraphQL)
• Notificações e muito mais!

O Back4App pode ajudar a acelerar significativamente o tempo de lançamento do seu produto no mercado.

Usando a plataforma, você pode focar no core do seu negócio, sem se preocupar com o backend ou com a infraestrutura subjacente.

Além disso, não será necessário contratar engenheiros especializados em DevOps, o que reduz os custos de manutenção do seu sistema.

A melhor parte é que o Back4App oferece um plano gratuito. O plano gratuito é excelente para testar a plataforma ou hospedar pequenos projetos.

Se o seu aplicativo se tornar bem-sucedido, você pode fazer upgrade para os planos premium.

Visão Geral do Projeto

Para demonstrar como criar um backend, construiremos um serviço simples de backend para um e-commerce. O backend permitirá gerenciar produtos, categorias e pedidos.

O diagrama ER (Entidade-Relacionamento) do nosso projeto ficará assim:

Vamos criar o backend com uma quantidade mínima de código e demonstrar como ele pode ser utilizado no lado do cliente, por meio de SDKs, REST API, e GraphQL API.

Criar Aplicação

Para seguir adiante, é necessário ter uma conta no Back4app. Precisa de uma? Inscreva-se hoje mesmo!

Após fazer login na sua conta Back4app, você verá a lista das suas aplicações. Clique no botão “Criar aplicação” para iniciar o processo de construção da aplicação.

Em seguida, selecione “BaaS” porque estamos configurando um backend.

Escolha um nome para a aplicação, selecione “NoSQL” e crie a aplicação.

O Back4app vai levar algum tempo para configurar tudo. Ele vai gerenciar a camada de aplicação, banco de dados, backups, escalabilidade e mais.

Assim que a aplicação for criada, você será levado ao banco de dados em tempo real da sua aplicação.

Configurar o Banco de Dados

Agora que criamos nossa aplicação, vamos cuidar do banco de dados.

Primeiro, precisamos criar uma classe para armazenar os dados no banco de dados. Você pode entender classes como tabelas (terminologia SQL) ou modelos (terminologia ORM).

Cada classe tem os seguintes quatro campos por padrão:

+-------------+-------------+------------------------------------------+
| Tipo        | Nome        | Descricão                                |
+-------------+-------------+------------------------------------------+
| String      | objectId    | Identificador único do objeto            |
+-------------+-------------+------------------------------------------+
| Date        | updatedAt   | Data e hora da última atualização        |
+-------------+-------------+------------------------------------------+
| Date        | createdAt   | Data e hora de criação                   |
+-------------+-------------+------------------------------------------+
| ACL         | ACL         | Lista de Controle de Acesso (ACL)        |                
+-------------+-------------+------------------------------------------+

Conforme mencionado na visão geral do projeto, nosso projeto terá três classes. Crie a primeira clicando no botão “Criar classe” na barra lateral. Nomeie-a como ProductCategory:

Adicione os seguintes campos:

+-----------------------------+-------------+---------------+----------+
| Tipo                        | Nome        | Valor padrão  | Requerido|
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | sim      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | não      |
+-----------------------------+-------------+---------------+----------+

Realize os mesmos passos para a classe Product:

+-----------------------------+-------------+---------------+----------+
| Tipe                        | Nome        | Valor padrão | Requerido |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ProductCategory | categories  | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Number                      | price       | 0             | yes      |
+-----------------------------+-------------+---------------+----------+

Usamos o tipo de dado Relação para lidar com o relacionamento muitos-para-muitos.

Lastly, create the Order class:

+-----------------------------+------------+---------------+----------+
| Tipo de dado                | Nome       | Valor padrão  | Requerido|
+-----------------------------+------------+---------------+----------+
| Pointer -> Product          | product    | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cFirstName | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cLastName  | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| String                      | cAddress   | <leave blank> | yes      |
+-----------------------------+------------+---------------+----------+
| Number                      | delivered  | false         | yes      |
+-----------------------------+------------+---------------+----------+

Usamos o tipo de dado Pointer para lidar com o relacionamento um-para-muitos.

Depois de concluir, você deverá ver as classes na barra lateral.

Popular o banco de dados

Agora, vamos popular o banco de dados.

Comece criando algumas categorias de produtos, produtos e pedidos (nesta ordem). Se estiver sem ideias, sinta-se à vontade para importar esta fixture.

Para importar um arquivo JSON, use a opção “Mais opções > Importar > Dados da classe > Selecionar arquivo”. Certifique-se de importar os arquivos JSON na seguinte ordem:

1. ProductCategory.json
2. Product.json
3. _Join꞉categories꞉Product.json
4. Order.json

Por padrão, as classes do banco de dados são criadas no “Modo Protegido”.

Enquanto estiver no modo protegido, a única maneira de interagir e gerenciar objetos é usando a chave mestre. Isso não é ideal porque não podemos buscar ou gerenciar objetos no lado do cliente.

Para conseguir fazer isso, precisamos relaxar algumas restrições. O Back4app/Parse vem com dois mecanismos de restrição:

• Permissões a nível de classe (CLPs)
• Permissões a nível de acesso (ACLs)

As CLPs nos permitem impor restrições a nível de classe, enquanto as ACLs nos permitem impor restrições a nível de objeto. Ambos os mecanismos podem restringir uma classe ou objeto a uma função ou usuário específico.

Selecione a classe Product na barra lateral e clique no texto “Protegido” na parte superior da tela. Em seguida, modifique as CLPs:

Depois de concluir, você deverá ter alguns produtos, categorias e pedidos no seu banco de dados. Este passo é necessário porque precisaremos de alguns dados para testar o backend na fase posterior.

Realize os mesmos passos para o modelo ProductCategory.

Em seguida, atualize as CLPs para a classe Order.

Preste atenção à imagem. Aqui, também estamos ativando a permissão de Criação.

As novas CLPs permitirão que usuários não autenticados busquem, consultem e contem Produtos e Categorias de Produtos, mas sem modificá-los. O mesmo se aplica à classe Order, mas, nesse caso, os usuários também poderão criar novos pedidos.

Para saber mais, confira nosso artigo sobre Segurança no Parse Server.

Admin App

No momento, a única maneira de gerenciar objetos no seu banco de dados é usando a visualização do banco de dados.

Embora isso funcione para desenvolvedores, não é intuitivo para usuários não técnicos. Além disso, dá aos usuários muito controle e é propenso a erros humanos.

Felizmente, o Back4app permite ativar facilmente a funcionalidade “Admin App”. O Admin App é um painel de administração fácil de usar, personalizado para as classes do seu banco de dados.

Ative-o primeiro navegando até “Mais > Admin App” na barra lateral. Em seguida, clique em “Ativar”:

O Back4app solicitará que você escolha um nome de usuário, senha e subdomínio. Eu decidi usar o seguinte:

user:        root
pass:        complexpassword123
subdomain:   https://binfra.admin.back4app.com/

Ótimo, é tudo o que você precisa fazer.

Você pode acessar o painel de administração clicando na “URL do Admin App”. Ao clicar, uma nova janela do navegador será aberta, e você será solicitado a inserir suas credenciais de administrador. Após fazer login, você poderá criar, atualizar e excluir objetos.

Experimente explorar o painel para se familiarizar com ele.

Cloud Code

O Back4app permite que você execute código JavaScript personalizado através do chamado Cloud Code.

Com o Cloud Code, você pode definir funções que podem ser acionadas pelo Parse, por requisições HTTP ou executadas periodicamente.

Além disso, o Cloud Code pode ser usado para construir aplicações web usando Express.

Função Cloud Code

Suponha que queremos uma função Cloud Code que calcule as vendas atuais.

Primeiro, navegue até “Cloud Code > Function & Web Hosting” na barra lateral. Você notará que a visualização do Cloud Code está dividida em duas partes.

No lado esquerdo, você pode ver a estrutura de diretórios e, no lado direito, o código.

Em seguida, abra o arquivo cloud/main.js e cole o seguinte código:

// cloud/main.js

Parse.Cloud.define("calculateSales", async (request) => {
  const orderClass = Parse.Object.extend("Order");
  const orderQuery = new Parse.Query(orderClass);
  let sales = 0;

  try {
    const orders = await orderQuery.find();

    for (var i = 0; i < orders.length; i++) {
      let order = orders[i];
      let productId = order.get("product")["id"];

      const productClass = Parse.Object.extend("Product");
      const productQuery = new Parse.Query(productClass);
      const product = await productQuery.get(productId);

      sales += product.get("price");
    }
    return { 
      sales: sales,
    };
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
    return {
      sales: 0,
    }
  }
});

Parse.Cloud.job("printSales", async (request, status) => {
  try {
    const result = await Parse.Cloud.run("calculateSales");
    console.log("Sales: " + result.sales + "$");
  } catch (error) {
    console.error("Error calculating the sales: " + error.message);
  }
});

• Definimos uma função Cloud Code chamada calculateSales(). A função percorre todos os pedidos, busca os produtos correspondentes e soma seus preços.

• Também definimos um Job Cloud Code chamado printSales(), permitindo que a função seja executada a partir do painel do Parse e programada para ser executada periodicamente.

Por fim, clique em “Deploy” para implantar o Cloud Code.

Certifique-se de que o job funciona navegando até “Cloud Code > Jobs” na barra lateral e, em seguida, executando o job printSales(). Se tudo correr bem, você deverá ver uma mensagem dizendo, por exemplo, “Vendas: 1440$” ao verificar os logs.

Agendamento de Cloud Code

Para agendar o job, você deve navegar até “App Settings > Server Settings” na barra lateral. Role até “Tarefas em segundo plano”, clique em “Agendar um job” e preencha o formulário.

Para garantir que está funcionando, verifique os logs mais uma vez.

Lado do cliente

Existem várias maneiras de interagir com o backend baseado no Back4app:

• Parse SDK
• API RESTful (auto-gerada)
• API GraphQL (auto-gerada)

Como regra geral, você deve sempre usar o Parse SDK se ele estiver disponível para sua plataforma. Caso contrário, utilize a API RESTful ou a API GraphQL. A escolha entre as APIs depende dos seus dados.

Saiba como usar o Parse SDK com vários frameworks consultando a documentação.

No entanto, vamos testar nosso backend usando o Console REST integrado.

Navegue até “API > REST” na barra lateral e tente consultar todos os produtos preenchendo o formulário:

Você deverá obter uma resposta similar:

{
    "results": [
        {
            "objectId": "4ZyHH3X0RQ",
            "name": "Fitness Tracker Watch",
            "description": "...",
            "price": 80,
            "createdAt": "2023-10-17T20:03:55.424Z",
            "updatedAt": "2023-10-17T20:24:12.322Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
        {
            "objectId": "cDqlGJzT5U",
            "name": "Organic Fruit Basket",
            "description": "...",
            "price": 40,
            "createdAt": "2023-10-17T20:04:10.063Z",
            "updatedAt": "2023-10-17T20:24:00.382Z",
            "categories": {
                "__type": "Relation",
                "className": "ProductCategory"
            }
        },
    // ...
}

Tente realizar as seguintes consultas:

• Buscar todos os produtos que custam mais de 50
• Buscar todos os pedidos que ainda não foram entregues
• Criar um novo produto e adicionar uma categoria a ele
• Excluir um pedido

Conclusão

Em conclusão, agora você sabe o que é infraestrutura de backend, está familiarizado com vários tipos de infraestruturas de backend e sabe como escolher a infraestrutura adequada para o seu projeto.

Além disso, você aprendeu como criar uma infraestrutura de backend no Back4app. Você cuidou do banco de dados, segurança do banco de dados, código personalizado, agendamento de jobs e testes de API.

Para orientações sobre como criar o lado cliente para um backend baseado no Back4app, explore nossos outros artigos:

• Como hospedar frontend e backend?
• Como desenvolver um aplicativo de mídia social?
• Como construir um chatbot usando React?

Recursos adicionais de artigos estão disponíveis como código aberto em um repositório no GitHub.