O que são funções sem servidor?

Neste artigo, falaremos sobre computação sem servidor, várias arquiteturas de software, funções sem servidor, seus benefícios e casos de uso. Na segunda parte do artigo, aprenderemos a criar um backend sem servidor no Back4app usando as funções do Cloud Code.

O que é uma função sem servidor?

Uma função sem servidor é um trecho de código orientado por eventos que atende a uma única finalidade. Ela pode ser acionada por eventos específicos, como solicitações HTTP, alterações no banco de dados ou outras mensagens. Essas funções são escritas por um desenvolvedor de software e, posteriormente, implantadas na nuvem. O provedor de nuvem gerencia a infraestrutura, a segurança, cuida da execução do código e dimensiona automaticamente os recursos com base na demanda.

As funções sem servidor são frequentemente confundidas com a computação sem servidor. Embora os termos estejam relacionados um ao outro, eles não podem ser usados de forma intercambiável. A computação sem servidor é um modelo de computação em nuvem em que os provedores de nuvem gerenciam a infraestrutura necessária para executar os aplicativos, enquanto as funções sem servidor são um tipo de computação sem servidor que permite que os desenvolvedores executem e implementem facilmente pequenos trechos de código na nuvem.

Como funcionam as funções sem servidor?

A maioria dos aplicativos modernos é dividida em duas partes: o frontend e o backend. O frontend é o que o usuário vê e com o qual pode interagir, enquanto o backend é tudo o que o usuário não pode ver. Isso inclui lógica de negócios, armazenamento de dados, bancos de dados, APIs e assim por diante.

As funções sem servidor simplificam o componente de backend dos aplicativos de software, dividindo o backend em várias funções reutilizáveis de finalidade única. Essas funções podem ser conectadas posteriormente para executar tarefas complexas.

A maneira mais fácil de entender as funções sem servidor é examinar um exemplo do mundo real. Suponhamos que tenhamos uma loja de comércio eletrônico em que um usuário possa visualizar produtos, adicionar produtos ao carrinho, remover produtos do carrinho e finalizar a compra.

Nosso backend sem servidor provavelmente incluiria as seguintes funções:

getProductList()                       -> retrieves the products from the database
getProduct(productId)                  -> retrieves a specific product from the database
getCart(user)                          -> returns the products in the user's cart
addToCart(user, productId)             -> adds a product to the user's cart
removeFromCart(user, productId)        -> removes the product from the user's cart
clearCart(user)                        -> clears user's cart

E também teríamos funções mais complexas que utilizam outras funções sem servidor:

checkout()
    cart = getCart(user)
    finalizeCheckout(user, cart)       -> deducts money from user's account
    clearCart(user)
    sendConfirmationEmail(user, cart)  -> sends a confirmation email to the user

Certo, mas como as funções sem servidor funcionam nos bastidores?

Por trás disso, as funções sem servidor funcionam aproveitando a tecnologia de conteinerização, que envolve o empacotamento do código em contêineres leves e isolados que podem ser facilmente implantados e dimensionados sob demanda. Quando uma função sem servidor é acionada, o provedor de nuvem cria uma nova instância do contêiner, executa o código nele e, em seguida, encerra o contêiner quando o código termina de ser executado.

O provedor de nuvem normalmente lida com todos os aspectos do gerenciamento da infraestrutura subjacente, inclusive dimensionamento, balanceamento de carga e alocação de recursos, de modo que os desenvolvedores não precisam se preocupar em configurar ou gerenciar servidores. Em vez disso, os desenvolvedores simplesmente escrevem o código, fazem upload dele para o provedor de nuvem e definem as condições de acionamento para quando o código deve ser executado.

Quais são as diferentes arquiteturas de software?

Além das funções sem servidor, também temos a arquitetura monolítica e a arquitetura de microsserviços. Vamos dar uma olhada nelas.

Arquitetura monolítica

Em uma arquitetura monolítica, o aplicativo é criado como uma única unidade com todos os componentes fortemente integrados. Todas as funcionalidades são combinadas em uma única base de código, e o aplicativo é implantado como um único pacote. A arquitetura monolítica é simples de criar e manter, mas pode se tornar complexa e difícil de dimensionar à medida que o aplicativo cresce.

Arquitetura de microsserviços

A arquitetura de microsserviços é uma abordagem para a criação de aplicativos de software como uma coleção de serviços pequenos e independentes que se comunicam entre si por meio de APIs. Cada microsserviço é responsável por uma função específica do aplicativo e pode ser desenvolvido, implantado e dimensionado de forma independente. Essa abordagem permite maior flexibilidade, escalabilidade e resiliência, mas também pode introduzir complexidade em termos de comunicação e gerenciamento de serviços.

Concluindo, os aplicativos monolíticos são mais adequados para projetos mais simples que não precisam de muito dimensionamento. Por outro lado, os microsserviços e a arquitetura sem servidor são geralmente mais apropriados para projetos mais complexos que precisam ser altamente dimensionáveis e flexíveis. Além de todas as vantagens dos microsserviços, a arquitetura sem servidor também abstrai o gerenciamento da infraestrutura. Portanto, você economiza muito tempo e dinheiro.

Quais são os benefícios das funções sem servidor?

As funções como serviço (FaaS) trazem muitos benefícios.

Desenvolvimento mais rápido

As funções sem servidor permitem o desenvolvimento e a implementação mais rápidos, pois não há necessidade de gerenciar a infraestrutura, configurar os servidores, definir o dimensionamento ou gerenciar os servidores. Como as funções sem servidor são pequenos trechos de código que atendem a uma única finalidade, elas podem ser facilmente testadas e depuradas. E o melhor de tudo é que as funções sem servidor podem ser facilmente integradas a outros serviços de nuvem ou APIs de terceiros, eliminando muitos problemas comuns.

Alta escalabilidade e disponibilidade

As funções sem servidor podem lidar com um grande número de solicitações e escalar automaticamente com base na demanda. Isso garante que o aplicativo possa acomodar qualquer nível de tráfego. Além disso, se ninguém estiver usando o seu serviço, o ambiente pode ser dimensionado para zero, economizando muito dinheiro.

Também é possível implantar suas funções como serviço (FaaS) em várias zonas. Isso pode ajudá-lo a melhorar a disponibilidade do seu aplicativo, distribuindo suas funções em todo o mundo.

Maior flexibilidade

As funções sem servidor permitem que os desenvolvedores escolham a linguagem de programação e as ferramentas que melhor atendam às suas necessidades. A maioria dos fornecedores sem servidor oferece suporte a várias linguagens, como JavaScript, Java, Python, Go e .NET. Isso proporciona maior flexibilidade no desenvolvimento e na implantação de aplicativos.

Custo-benefício

A arquitetura sem servidor é a mais econômica, pois você só paga pelo que consome. Esse é o tempo de execução de suas funções e outros serviços gerenciados que suas funções usam. Além disso, você não precisa pagar por recursos ociosos.

Quais são alguns dos casos de uso das funções sem servidor?

As funções sem servidor podem ser usadas em praticamente qualquer projeto. Você pode usar funções sem servidor para criar o projeto desde o início ou apenas para tarefas específicas. Os principais casos de uso incluem:

• Aplicativos da Web
• Criação de APIs RESTful
• Tarefas baseadas em gatilhos
• Automação de tarefas programadas
• Processamento assíncrono
• Internet das Coisas (IoT)
• CI/CD

A maioria das equipes de desenvolvedores migra para o serverless em etapas. Elas migram tarefa por tarefa até que não haja mais necessidade de servidores tradicionais.

Quais são os exemplos de ambientes sem servidor?

Plataforma como serviço (PaaS)

A PaaS (Platform as a Service, plataforma como serviço) é uma solução vantajosa de computação em nuvem que oferece aos usuários a capacidade de criar, gerenciar e implementar aplicativos em um ambiente baseado em nuvem.

Ele fornece ferramentas pré-configuradas para o desenvolvimento, a personalização e o teste de aplicativos, eliminando grande parte do tempo gasto com o gerenciamento da infraestrutura.

O desenvolvimento de um aplicativo que será implantado na PaaS não é muito diferente da criação de um aplicativo tradicional. Os fornecedores de PaaS não oferecem suporte imediato a funções sem servidor.

Os serviços de PaaS incluem: Heroku, AWS Elastic Beanstalk, DigitalOcean App Platform e Fly.io.

Backend como serviço (BaaS)

O BaaS otimiza e simplifica o desenvolvimento de back-end, fornecendo uma plataforma para gerenciar a infraestrutura de nuvem.

Ele lida com todas as tarefas tediosas associadas à criação de um backend, permitindo que os desenvolvedores se concentrem na criação de aplicativos. Ao automatizar muitos desses processos, o BaaS ajuda os desenvolvedores a criar aplicativos robustos com rapidez e eficiência.

A plataforma oferece uma ampla gama de recursos, incluindo gerenciamento de usuários, notificações, integrações de mídia social e armazenamento. Isso a torna a opção ideal para empresas que desejam desenvolver sua presença digital. Além disso, ela oferece conveniência e facilidade de uso, o que a torna acessível a usuários de todos os tipos.

Os desenvolvedores ficam livres da necessidade de se preocupar com a infraestrutura de back-end e, em vez disso, podem concentrar seus esforços na criação do front-end de seus projetos. Isso permite que eles se concentrem no negócio principal sem precisar dedicar tempo e energia a outras tarefas.

Alguns fornecedores de BaaS também nos permitem implementar funções sem servidor:

• O Back4app tem funções do Cloud Code
• O Firebase tem o Google Cloud Functions
• O AWS Amplify tem o AWS Lambda

Outros fornecedores de BaaS incluem Supabase, Kinvey e Parse.

Função como serviço (FaaS)

A função como serviço (FaaS) é um modelo de computação em nuvem especializado em funções sem servidor. O FaaS permite que os desenvolvedores se concentrem em escrever e implementar funções individuais em vez de criar e gerenciar uma pilha completa de aplicativos. As funções sem servidor geralmente se integram a APIs de terceiros e a outros serviços de nuvem. Esse modelo de computação pode ser dimensionado automaticamente e rapidamente para acomodar qualquer tráfego.

As principais diferenças entre BaaS e FaaS estão em:

• Construção de aplicativos
• Escalabilidade
• Modelo de precificação

As funções sem servidor são executadas em contêineres, são mais escaláveis e mais econômicas, pois você só paga pelo tempo de execução das funções. A BaaS, por outro lado, tem muitos recursos integrados, como gerenciamento de usuários, notificações push, integrações de mídia social e outras ferramentas prontas para uso que permitem criar back-ends rapidamente. Além disso, o BaaS é extremamente fácil de usar.

Alguns exemplos de FaaS incluem: AWS Lambda, Google Cloud Functions e Azure Functions.

Criação de um back-end sem servidor no Back4app

Nesta seção do tutorial, demonstraremos como codificar e implementar funções do Cloud Code no Back4app. Além disso, aprenderemos a conectar um frontend a um backend sem servidor.

Objetivos:

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

• Explicar o que são as funções do Cloud Code e como elas funcionam
• Codifique suas funções do Cloud Code que podem manipular o banco de dados
• Use as funções do Cloud Code para buscar dados de APIs de terceiros
• Crie seus próprios Cloud Jobs e agende-os
• Conectar um projeto de front-end a um back-end sem servidor

O que é o Back4app?

A Back4app é uma plataforma líder de BaaS (Backend as a Service) que fornece aos desenvolvedores as ferramentas e os recursos necessários para criar facilmente aplicativos móveis e da Web.

Com seu conjunto abrangente de vantagens, ele permite que os desenvolvedores se concentrem nos principais aspectos de seus negócios, em vez de se preocuparem com complexidades de backend ou problemas de infraestrutura. É uma das soluções de BaaS de código aberto mais preferidas disponíveis atualmente.

A solução abrangente vem com um painel interativo e uma interface de linha de comando (CLI) flexível para máxima conveniência. Além disso, fornece SDKs compatíveis com React Native, Flutter, Node.js, Angular, iOS, Android e outros, o que facilita a integração com os sistemas existentes!

Os principais recursos do Back4app incorporam um banco de dados em estilo de planilha, APIs GraphQL e REST, consultas em tempo real, autenticação com opções de login social, escalabilidade para hospedagem e notificações, todos disponíveis nessa plataforma avançada.

Para obter informações adicionais, leia Recursos do Back4app.

A Back4app oferece um modelo econômico para todos os tipos de aplicativos, desde os pequenos até os grandes. Eles fornecem um plano complementar que é perfeito para o desenvolvimento e a experimentação da plataforma.

Introdução ao projeto

Criaremos um aplicativo simples de gerenciamento de estações meteorológicas. Primeiro, criaremos estações meteorológicas virtuais e, em seguida, usaremos a WeatherAPI para obter informações meteorológicas reais nos locais das estações meteorológicas. Para definir a lógica do nosso aplicativo, usaremos funções do Cloud Code e Cloud Jobs. No final, demonstraremos como conectar facilmente um projeto de front-end a um back-end sem servidor.

Criar aplicativo

Se você ainda não tiver uma conta Back4app, inscreva-se agora para aproveitar os serviços gratuitos. Caso contrário, faça login em sua conta existente e prossiga com as etapas a seguir.

Para começar a usar o Back4app, você precisará criar um aplicativo. Faça login no seu painel para ver a lista de aplicativos e clique em “Build new app” (Criar novo aplicativo) para começar a criar seu aplicativo.

Como usaremos a estrutura do Parse para criar nosso aplicativo, selecione “Backend as a Service”.

Em seguida, insira um nome de aplicativo personalizado, selecione “NoSQL Database” como seu banco de dados e, por fim, clique em “Create”.

A Back4app configurará todos os componentes necessários para seu aplicativo, inclusive o banco de dados, a camada de aplicativos, o dimensionamento, os backups e a segurança. Isso leva pouco tempo para ser feito.

Depois que sua inscrição for concluída, você será redirecionado para o painel do seu aplicativo.

Banco de dados

Vamos definir nossos modelos de banco de dados. Criaremos dois modelos:

1. WeatherStation representa uma estação meteorológica virtual localizada em algum local.
2. O WeatherRecord representa uma medição do tempo em uma WeatherStation específica.

Navegue até o “Banco de dados” e clique em “Criar uma classe”. Dê a ela o nome de WeatherStation, certifique-se de ativar “Public Read and Write” (Leitura e gravação públicas) e adicione os seguintes campos a ela:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| String                    | name            | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | location        | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Em seguida, siga as mesmas etapas para criar outra classe chamada WeatherRecord com os seguintes campos:

+---------------------------+-----------------+---------------+----------+
| Data type                 | Name            | Default value | Required |
+---------------------------+-----------------+---------------+----------+
| Pointer -> WeatherStation | weatherStation  | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherText     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| String                    | weatherIcon     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+
| Number                    | weatherCode     | <leave blank> | yes      |
+---------------------------+-----------------+---------------+----------+

Por fim, navegue até o modelo WeatherStation e crie duas estações meteorológicas. Exemplo:

+---------------------------+---------------+
| name                      | location      |
+---------------------------+---------------+
| Sunnyvale Station         | sunnyvale     |
+---------------------------+---------------+
| Mountain View Station     | mountain view |
+---------------------------+---------------+

Ótimo, isso é tudo para o banco de dados.

API de clima

Para obter as informações meteorológicas atuais, usaremos uma API gratuita chamada WeatherAPI.

As etapas a seguir exigirão que você tenha uma conta WeatherAPI. Se ainda não tiver uma, inscreva-se, caso contrário, faça login em seu painel.

Quando estiver conectado, anote sua chave de API:

Em seguida, abra seu terminal e tente obter as informações meteorológicas atuais de “Sunnyvale” usando sua chave de API:

curl "https://api.weatherapi.com/v1/current.json?key=<your_api_key>&q=<location>&aqi=no"

# Example:
# curl "https://api.weatherapi.com/v1/current.json?key=354fc376a4c&q=Sunnyvale&aqi=no"

Você deve receber uma resposta semelhante a esta:

{
    "location": {
        "name": "Sunnyvale",
        "region": "California",
        "country": "United States of America",
        "lat": 37.37,
        "lon": -122.04,
    },
    "current": {
        "temp_c": 7.0,
        "temp_f": 44.6,
        "is_day": 1,
        "condition": {
            "text": "Light rain",
            "icon": "//cdn.weatherapi.com/weather/64x64/day/296.png",
            "code": 1183
        },
        ...
    }
}

Na próxima seção do artigo, usaremos as funções do Cloud Code para buscar informações meteorológicas da WeatherAPI e armazená-las no banco de dados.

Código de nuvem

As funções do Cloud Code são um recurso avançado do Parse Server que permite que os desenvolvedores executem código JavaScript personalizado no lado do servidor. Os desenvolvedores podem usar essas funções para implementar a lógica comercial, validar dados, processar dados complexos e criar back-ends sem servidor em geral.

Navegue até o painel de controle do aplicativo Back4app e selecione “Funções e hospedagem na Web” em “Código de nuvem” na barra lateral.

A interface de usuário do Back4app Cloud Code é fácil de usar. No lado esquerdo da tela, você pode ver a estrutura de diretórios. Por padrão, há dois diretórios:

1. cloud é um diretório para todo o código da nuvem
2. public é um diretório para arquivos públicos, como imagens, folhas de estilo e outros

E, no lado direito da tela, você tem um editor de código integrado.

Definir funções do Cloud Code

Definiremos as seguintes funções:

1. weatherLocations retorna a lista de locais de estações meteorológicas.
2. weatherInfo retorna o boletim meteorológico de um local específico.

Mas antes disso, vamos instalar um pacote de terceiros chamado axios. O Axios é um cliente HTTP baseado em promessas para JavaScript que simplifica muito a realização de solicitações HTTP.

Crie um novo arquivo chamado package.json dentro da pasta da nuvem e coloque o seguinte:

{
  "dependencies": {
    "axios": "*"
  }
}

Em seguida, defina as funções do Cloud Code em cloud/main.js da seguinte forma:

// cloud/main.js

const axios = require("axios");

// make sure to replace `<api_key>` with your actual WeatherAPI key
const WEATHER_API_BASE = "https://api.weatherapi.com/v1/current.json?key=<api_key>";

Parse.Cloud.define("weatherLocations", async (request) => {
  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  return weatherStationResults.map(result => result.get("location"))
});

Parse.Cloud.define("weatherInfo", async (request) => {
  let location = request.params.location;

  if (!location) {
    throw new Parse.Error(400, "Location not provided.");
  }

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  weatherStationQuery.equalTo("location", location);
  const weatherStationResults = await weatherStationQuery.find();

  if (weatherStationResults.length == 0) {
    throw new Parse.Error(400, "Invalid location.");
  }

  const WeatherRecord = Parse.Object.extend("WeatherRecord");
  const weatherRecordQuery = new Parse.Query(WeatherRecord);
  weatherRecordQuery.equalTo("weatherStation", weatherStationResults[0]);
  weatherRecordQuery.descending("createdAt");
  weatherRecordQuery.limit(5);
  const weatherRecordResults = await weatherRecordQuery.find();

  return weatherRecordResults;
});

Por fim, clique em “Deploy” (Implantar) no canto inferior direito da tela para implantar suas funções no Back4app.

Trabalho na nuvem

Os Cloud Jobs permitem que os desenvolvedores executem trabalhos em segundo plano, como o envio de notificações push ou o processamento de dados. Esses trabalhos são escritos de forma semelhante às funções do Cloud Code e podem ser programados para serem executados em uma base única ou recorrente.

Vamos criar um Cloud Job que mede o clima em todas as nossas estações meteorológicas a cada 30 minutos.

Definir trabalho na nuvem

Selecione “Cloud Code” (Código da nuvem) na barra lateral e cole o seguinte código na parte inferior do arquivo cloud/main.js:

// cloud/main.js

// ...

Parse.Cloud.job("weatherCapture", async (request) => {
  const {params, headers, log, message} = request;
  message("weatherCapture just started...");

  const WeatherStation = Parse.Object.extend("WeatherStation");
  const weatherStationQuery = new Parse.Query(WeatherStation);
  const weatherStationResults = await weatherStationQuery.find();

  for (let i = 0; i < weatherStationResults.length; i++) {
    let weatherStation = weatherStationResults[i];

    try {
      const response = await axios.get(
        WEATHER_API_BASE + "&q=" + weatherStation.get("location") + "&aqi=no"
      );
      const currentWeather = response.data.current.condition;
      let icon = currentWeather.icon
        .replace("//", "https://")
        .replace("64x64", "128x128");

      const WeatherRecord = Parse.Object.extend("WeatherRecord");
      const weatherRecord = new WeatherRecord();
      weatherRecord.set("weatherStation", weatherStation);
      weatherRecord.set("weatherText", currentWeather.text);
      weatherRecord.set("weatherIcon", icon);
      weatherRecord.set("weatherCode", currentWeather.code);
      weatherRecord.save();
    } catch (error) {
      throw new Parse.Error(400, error);
    }
  }

  message("weatherCapture just finished!");
});

Esse código define um novo trabalho na nuvem chamado weatherCapture. O trabalho percorre todo o WeatherStation, obtém as informações meteorológicas da WeatherAPI e as armazena no banco de dados.

Para testar se ele funciona, navegue até “Jobs > All Jobs” na barra lateral e tente executar o trabalho. Se tudo correr bem, deverá haver dois novos WeatherRecord no banco de dados posteriormente.

Agendar trabalho na nuvem

Vamos programar o trabalho para ser executado a cada 30 minutos.

Selecione “App Settings > Server Settings” na barra lateral e procure por “Background Jobs”. Em seguida, clique no botão “Settings” (Configurações):

Em seguida, agende um novo trabalho com os seguintes detalhes:

1. Descrição: Mede o tempo em todas as estações
2. Trabalho na nuvem: weatherCapture
3. Parâmetros: Deixar em branco
4. Horário do cronograma: Início imediato
5. Ele deve se repetir? Sim
6. Frequência: Intervalo
7. Em que intervalo ele será repetido? 30 minutos

É isso aí. O trabalho weatherCapture agora será executado a cada 30 minutos.

Nosso backend sem servidor agora está pronto. Na próxima seção, veremos como conectar um frontend ao backend sem servidor.

Front-end

A criação de um frontend personalizado desde o início está fora do escopo deste tutorial. No entanto, vou descrever as etapas básicas para conectar um frontend JavaScript a um backend sem servidor.

• Instale o Parse via npm ou yarn e importe-o.
• Inicialize o Parse em seu App.js ou _app.js da seguinte forma:

import Parse from "parse/dist/parse.min.js";
    
// to get the keys navigate to your Back4app app > App Settings > Security & Keys
Parse.initialize(
  "<your_app_id>",              // replace me
  "<your_javascript_key>",      // replace me
);
Parse.serverURL = "https://parseapi.back4app.com/";

• Em seguida, você pode chamar funções do Cloud Code como esta:

const fetchWeatherLocations = async () => {
    return await Parse.Cloud.run("weatherLocations");
};

Para obter mais informações, consulte a documentação oficial.

Também preparei um projeto de amostra para o backend de nossa estação meteorológica. O projeto pode ser acessado no GitHub. O README.md contém todas as informações de que você precisa para colocar o projeto em funcionamento localmente. Sinta-se à vontade para fazer um fork e brincar com ele.

Conclusão

A computação sem servidor tornou-se uma solução cada vez mais popular para os desenvolvedores que desejam criar e implementar aplicativos sem se preocupar com o gerenciamento de servidores.

Neste artigo, exploramos várias arquiteturas de software, analisamos as funções sem servidor e destacamos seus benefícios e casos de uso. Por fim, demonstramos como criar um backend sem servidor simples no Back4app usando as funções do Cloud Code.

O código-fonte final pode ser encontrado no repositório back4app-serverless no GitHub.

Etapas futuras

1. Dê uma olhada no Parse Server Security para tornar seu backend mais seguro.
2. Dê uma olhada no The Ultimate Guide to Deploy Docker Apps para saber como criar e implantar um frontend personalizado nos contêineres do Back4app.
3. Saiba mais sobre o Parse Triggers.

PERGUNTAS FREQUENTES