Criando um aplicativo usando o Serverless Framework, AWS e BigQuery

Serverless refere-se a aplicativos em que o gerenciamento e a alocação de servidores e recursos são gerenciados por um provedor de nuvem. Isso significa que o provedor de nuvem aloca os recursos dinamicamente. O aplicativo está sendo executado em um contêiner sem estado que pode ser acionado por um evento. Um desses exemplos acima e o que usaremos neste artigo é sobre o AWS Lambda .

Em resumo, podemos determinar “aplicativos sem servidor” como aplicativos que são sistemas baseados em nuvem orientados a eventos. O aplicativo depende de serviços de terceiros, lógica do lado do cliente e chamadas remotas (chamando-o diretamente de Function as a Service ).

Instalando o Serverless Framework e configurando-o para Amazon AWS

1. Estrutura sem servidor

O Serverless Framework é um framework de código aberto. Ele consiste em uma interface de linha de comando ou CLI e um painel hospedado, que nos fornece um sistema de gerenciamento de aplicativos totalmente sem servidor. O uso do Framework garante menos despesas gerais e custos, desenvolvimento e implantação rápidos e proteção dos aplicativos sem servidor.

Antes de prosseguir com a instalação do framework Serverless, você deve primeiro configurar o NodeJS. É muito fácil de fazer na maioria dos sistemas operacionais – você só precisa visitar o site oficial do NodeJS para baixá-lo e instalá-lo. Lembre-se de escolher uma versão superior a 6.0.0.

Após instalá-lo, você pode confirmar que o NodeJS está disponível executando node -v no console. Ele deve retornar a versão do nó que você instalou:

Agora você está pronto, então vá em frente e instale a estrutura Serverless.

Para fazer isso, siga a documentação para configurar e configurar o framework. Se preferir, você pode instalá-lo apenas para um projeto, mas no DevriX, geralmente instalamos o framework globalmente: npm install -g serverless

Aguarde a conclusão do processo e certifique-se de que o Serverless foi instalado com sucesso executando: serverless -v

2. Crie uma conta Amazon AWS

Antes de continuar a criar seu aplicativo de exemplo, você deve criar uma conta no Amazon AWS . Se você ainda não tem uma, basta acessar a Amazon AWS e clicar em “Create an AWS account” no canto superior direito e seguir os passos para criar uma conta.

A Amazon exige que você insira um cartão de crédito, então você não pode continuar sem inserir essas informações. No registro e login bem-sucedidos, você deverá ver o Console de gerenciamento da AWS:

Excelente! Vamos prosseguir agora com a criação de seu aplicativo.

3. Configure o Serverless Framework com o provedor da AWS e crie um aplicativo de exemplo

Nesta etapa, temos que configurar o framework Serverless com o provedor da AWS. Alguns serviços, como o AWS Lambda, exigem credenciais quando você os acessa para garantir que você tenha permissões para os recursos pertencentes a esse serviço. A AWS recomenda usar o AWS Identity and Access Manager (IAM) para fazer isso.

Então, a primeira e mais importante coisa é criar um usuário do IAM na AWS para usá-lo em nossa aplicação:

No console da AWS:

• Digite IAM no campo “Localizar serviços” .
• Clique em “IAM” .
• Vá para “Usuários” .
• Clique em “Adicionar usuário” .

Para “Nome de usuário” use o que quiser. Por exemplo, estamos usando serverless-admin. Para “ Tipo de acesso” marque “Acesso programático” e clique em “Próximas permissões ”.

Depois disso, temos que anexar permissões para o usuário, clicar em “Anexar políticas existentes diretamente”, procurar por “Acesso de administrador” e clicar nele. Continue clicando em “Próximas tags”

As tags são opcionais, então você pode continuar clicando em “Próxima revisão” e “Criar usuário”. Uma vez feito e carregado, uma mensagem de sucesso aparece na página com as credenciais que precisamos.

Agora temos que executar o seguinte comando:
serverless config credentials --provider aws --key key --secret secret --profile serverless-admin
Substitua a chave e o segredo pelo fornecido acima. Suas credenciais da AWS são criadas como um perfil. Você pode verificar isso abrindo o arquivo ~/.aws/credentials . Ele deve consistir em perfis da AWS. Atualmente, no exemplo abaixo, é apenas um – o que criamos:

Ótimo trabalho até agora! Você pode continuar criando um aplicativo de exemplo usando NodeJS e os modelos de início integrados.

Nota: Além disso, no artigo, estamos usando o comando sls , que é a abreviação de serverless .
Crie um diretório vazio e insira-o. Execute o comando

ls create --template aws-nodejs

Usando o comando create –template , especifique um dos modelos disponíveis, neste caso, aws-nodejs, que é um aplicativo de modelo NodeJS “Hello world”.

Uma vez feito, seu diretório deve consistir no seguinte e se parecer com isso:

Criamos os novos arquivos handler.js e serverless.yml .

O arquivo handler.js armazena suas funções e serverless.yml armazena as propriedades de configuração que você alterará posteriormente. Se você está se perguntando o que é o arquivo .yml , em suma, é uma linguagem de serialização de dados legível por humanos . É bom estar familiarizado com ele, pois é usado ao inserir qualquer parâmetro de configuração. Mas vamos dar uma olhada no que temos no arquivo serverless.yml agora:

 serviço: aws-sample-application
fornecedor:
  nome: aw
  tempo de execução: nodejs12.x
funções:
  Olá:
    manipulador: handler.hello

• serviço: – Nosso nome de serviço.
• provedor: – Um objeto que contém propriedades do provedor, e como vemos aqui, nosso provedor é AWS, e estamos usando o runtime NodeJS.
• funções: – É um objeto que contém todas as funções que podem ser implantadas no Lambda. Neste exemplo, temos apenas uma função chamada hello que aponta para a função handler.js hello.

Você precisa fazer uma coisa crucial aqui antes de prosseguir com a implantação do aplicativo. Anteriormente, definimos as credenciais para AWS com um perfil (chamamos serverless-admin ). Agora tudo o que você precisa fazer é dizer à configuração sem servidor para usar esse perfil e sua região. Abra serverless.yml e sob a propriedade do provedor logo abaixo do tempo de execução, digite isto:

 perfil: serverless-admin
região: us-east-2

No final, devemos ter isso:

 fornecedor:
  nome: aw
  tempo de execução: nodejs12.x
  perfil: serverless-admin
  região: us-east-2

Observação: para obter a região, uma maneira fácil é pesquisar a URL quando você estiver logado no console: Exemplo:

Agora que temos as informações necessárias sobre nosso template gerado. Vamos verificar como podemos invocar a função localmente e implantá-la no AWS Lambda.
Podemos testar imediatamente a aplicação invocando a função localmente:

sls invoke local -f hello

Ele invoca a função (mas apenas localmente!) e retorna a saída para o console:

Agora, se tudo deu certo, você pode tentar implantar sua função no AWS Lambda .

Então foi complicado? Não, não foi! Graças ao Serverless Framework é apenas um código de uma linha:

sls deploy -v

Aguarde tudo terminar, pode demorar alguns minutos, se tudo estiver OK você deve terminar com algo assim:

Agora vamos verificar o que aconteceu na AWS. Vá para Lambda (em “ Find Services ” digite Lambda ), e você deverá ver sua função Lambda criada.

Agora você pode tentar invocar sua função do AWS Lambda. No tipo de terminal
sls invoke -f hello
Ele deve retornar a mesma saída anterior (quando testamos localmente):

Você pode verificar se acionou a função da AWS abrindo a função no AWS Lambda e acessando a guia “ Monitoramento ” e clicando em “ Visualizar logs no CloudWatch. “.

Você deve ter um log lá.

Agora, uma coisa ainda está faltando em seu aplicativo, mas o que é isso...? Bem, você não tem um endpoint para acessar para seu aplicativo, então vamos criá-lo usando o AWS API Gateway.

Você precisa abrir o arquivo serverless.yml e limpar os comentários primeiro. Você precisa adicionar uma propriedade de eventos à nossa função e sob sua propriedade http . Isso informa à estrutura Serverless para criar um API Gateway e anexá-lo à nossa função Lambda ao implantar o aplicativo. Nosso arquivo de configuração deve terminar assim:

 serviço: aws-sample-application
fornecedor:
  nome: aw
  tempo de execução: nodejs12.x
  perfil: serverless-admin
  região: us-east-2
funções:
  Olá:
    manipulador: handler.hello
    eventos:
      - http:
          caminho: /olá
          método: obter

Em http especificamos o caminho e o método HTTP.
É isso, vamos implantar nosso aplicativo novamente executando sls deploy -v

Quando terminar, uma coisa nova deve aparecer no terminal de saída, e esse é o endpoint que foi criado:

Vamos abrir o endpoint:

Você deve ver que sua função está sendo executada, retornando a saída e algumas informações sobre a solicitação. Vamos verificar o que está mudando em nossa função Lambda.

Abra o AWS Lambda e clique em sua função.

Vemos na guia “ Designer ” que temos o API Gateway anexado ao nosso Lambda e ao API Endpoint.

Excelente! Você criou um aplicativo sem servidor super simples, implantou-o no AWS Lambda e testou sua funcionalidade. Além disso, adicionamos um endpoint usando o AWS API Gateway .

4. Como executar o aplicativo offline

Até agora, sabemos que podemos invocar funções localmente, mas também podemos executar todo o nosso aplicativo offline usando o plugin serverless-offline.

O plug-in emula o AWS Lambda e o API Gateway em sua máquina local/de desenvolvimento. Ele inicia um servidor HTTP que trata das solicitações e invoca seus manipuladores.

Para instalar o plugin execute o comando abaixo no diretório do app

npm install serverless-offline --save-dev

Em seguida, dentro do serverless.yml do projeto, abra o arquivo e adicione a propriedade plugins :

 plug-ins:
  - off-line sem servidor

A configuração deve ficar assim:

 serviço: aws-sample-application
fornecedor:
  nome: aw
  tempo de execução: nodejs12.x
  perfil: serverless-admin
  região: us-east-2
funções:
  Olá:
    manipulador: handler.hello
    eventos:
      - http:
          caminho: /olá
          método: obter
plug-ins:
  - off-line sem servidor

Para verificar se instalamos e configuramos com sucesso o plugin, execute

sls --verbose

Você deve ver isso:

Agora na raiz do seu projeto, execute o comando

sls offline

Como você pode ver, um servidor HTTP está escutando na porta 3000, e você pode acessar suas funções, por exemplo, aqui temos http://localhost:3000/dev/hello para nossa função hello. Abrindo que temos a mesma resposta do API Gateway , que criamos anteriormente.

Adicionar integração do Google BigQuery

Você fez um ótimo trabalho até agora! Você tem um aplicativo totalmente funcional usando o Serverless. Vamos estender nosso aplicativo e adicionar a integração do BigQuery a ele para ver como está funcionando e como a integração é feita.

O BigQuery é um software como serviço (SaaS) sem servidor, que é um armazenamento de dados rápido e econômico que oferece suporte a consultas. Antes de continuarmos integrando-o ao nosso aplicativo NodeJS, precisamos criar uma conta, então vamos prosseguir.

1. Configure o Console do Google Cloud

Acesse https://cloud.google.com e faça login com sua conta, caso ainda não tenha feito isso – crie uma conta e prossiga.

Ao fazer login no Google Cloud Console, você precisa criar um novo projeto. Clique nos três pontinhos ao lado do logo e abrirá uma janela modal onde você escolhe “ Novo projeto. ”

Digite um nome para o seu projeto. Usaremos bigquery-example . Depois de criar o projeto, navegue até o BigQuery usando a gaveta:

Quando o BigQuery for carregado, no lado esquerdo, você verá os dados do projeto, aos quais você tem acesso, e também os conjuntos de dados públicos. Estamos usando um conjunto de dados público para este exemplo. É nomeado covid19_ecdc :

Brinque com o conjunto de dados e as tabelas disponíveis. Visualize os dados nele. Esse é um conjunto de dados público que é atualizado a cada hora e contém informações sobre dados mundiais do COVID-19 .

Temos que criar um usuário do IAM -> Conta de serviço para poder acessar os dados. Portanto, no menu, clique em “IAM e administrador” e depois em “Contas de serviço”.

Clique no botão “Criar conta de serviço” , digite o nome da conta de serviço e clique em “Criar”. Em seguida, vá para “ Permissões da conta de serviço” , pesquise e escolha “Admin do BigQuery” .

Clique em “ Continuar ”, este é o último passo, aqui você precisa de suas chaves, então clique no botão de criação em “ Chaves ” e exporte como JSON . Salve isso em algum lugar seguro, vamos precisar dele mais tarde. Clique em Concluído para concluir a criação da conta de serviço.

Agora, usaremos as credenciais geradas aqui para conectar a biblioteca NodeJS BigQuery.

2. Instale a biblioteca NodeJS BigQuery

Você precisará instalar a biblioteca NodeJS do BigQuery para usá-la no projeto que acabou de criar. Execute os comandos abaixo no diretório do aplicativo:

Primeiro, inicialize o npm executando npm init

Preencha todas as perguntas e prossiga com a instalação da biblioteca do BigQuery :
npm install @google-cloud/bigquery

Antes de continuarmos a alterar nosso manipulador de funções, precisamos carregar a chave privada do arquivo JSON que criamos anteriormente. Vamos usar variáveis ​​de ambiente Serverless para fazer isso. Você pode obter mais informações aqui.

Abra serverless.yml e, na propriedade do provedor , adicione a propriedade do ambiente como esta:

 meio Ambiente:
PROJECT_ID: ${file(./config/bigquery-config.json):project_id}
CLIENT_EMAIL: ${file(./config/bigquery-config.json):client_email}
PRIVATE_KEY: ${file(./config/bigquery-config.json):private_key}

Crie as variáveis ​​de ambiente PROJECT_ID, PRIVATE_KEY e CLIENT_EMAIL , que recebem as mesmas propriedades (minúsculas) do arquivo JSON que geramos. Nós o colocamos na pasta config e o nomeamos bigquery-config.json .

Agora, você deve acabar com o arquivo serverless.yml assim:

 serviço: aws-sample-application
fornecedor:
  nome: aw
  tempo de execução: nodejs12.x
  perfil: serverless-admin
  região: us-east-2
  meio Ambiente:
    PROJECT_ID: ${file(./config/bigquery-config.json):project_id}
    CLIENT_EMAIL: ${file(./config/bigquery-config.json):client_email}
    PRIVATE_KEY: ${file(./config/bigquery-config.json):private_key}
funções:
  Olá:
    manipulador: handler.hello
    eventos:
      - http:
          caminho: /olá
          método: obter
plug-ins:
  - off-line sem servidor

Agora abra handler.js e vamos importar a biblioteca do BigQuery, no topo do arquivo em 'use strict' adicione a seguinte linha:

const {BigQuery} = require('@google-cloud/bigquery');

Agora precisamos informar as credenciais à biblioteca do BigQuery. Para isso, crie uma nova constante que instancia o BigQuery com as credenciais:

 const bigQueryClient = new BigQuery({
    projectId: process.env.PROJECT_ID,
    credenciais: {
        client_email: process.env.CLIENT_EMAIL,
        private_key: process.env.PRIVATE_KEY
    }
});

Em seguida, vamos criar nossa consulta SQL do BigQuery. Queremos recuperar as informações mais recentes sobre os casos de COVID-19 na Bulgária. Estamos usando o editor de consultas do BigQuery para testá-lo antes de continuarmos. Por isso, criamos uma consulta personalizada:

 SELECT * FROM `bigquery-public-data.covid19_ecdc.covid_19_geographic_distribution_worldwide` WHERE geo_ ORDER BY data DESC LIMIT 1 

Boa! Agora vamos implementar isso em nosso aplicativo NodeJS.
Abra handler.js e cole o código abaixo

 const query = 'SELECT * FROM `bigquery-public-data.covid19_ecdc.covid_19_geographic_distribution_worldwide` WHERE geo_id = \'BG\' ORDER BY data DESC LIMIT 1';
opções const = {
    consulta: consulta
}

const [job] = await bigQueryClient.createQueryJob(options);
const [linhas] = aguardar job.getQueryResults();

Criamos constantes de consulta e opções . Em seguida, continuamos executando a consulta como um trabalho e recuperando os resultados disso.

Vamos também alterar nosso manipulador de retorno para retornar as linhas geradas da consulta:

 Retorna {
    código de status: 200,
    corpo: JSON.stringify(
        {
            linhas
        },
        nulo,
        2
    ),
};

Vamos ver o handler.js completo:

 'usar estrito';

const {BigQuery} = require('@google-cloud/bigquery');
const bigQueryClient = new BigQuery({
    projectId: process.env.PROJECT_ID,
    credenciais: {
        client_email: process.env.CLIENT_EMAIL,
        private_key: process.env.PRIVATE_KEY
    }
});

module.exports.hello = evento assíncrono => {
    const query = 'SELECT * FROM `bigquery-public-data.covid19_ecdc.covid_19_geographic_distribution_worldwide` WHERE geo_id = \'BG\' ORDER BY data DESC LIMIT 1';
    opções const = {
        consulta: consulta
    }

    const [job] = await bigQueryClient.createQueryJob(options);
    const [linhas] = aguardar job.getQueryResults();

    Retorna {
        código de status: 200,
        corpo: JSON.stringify(
            {
                linhas
            },
            nulo,
            2
        ),
    };
};

OK! Vamos testar nossa função localmente:
sls invoke local -f hello
Devemos ver a saída:

Prossiga com a implantação do aplicativo para testá-lo via HTTP Endpoints, então execute sls deploy -v

Aguarde a conclusão e abra o endpoint. Aqui estão os resultados:

Bem feito! Agora temos um aplicativo para recuperar dados do BigQuery e retornar uma resposta. Vamos finalmente verificar se está funcionando offline. Executar sls offline

E carregue o endpoint local:

Trabalho bem feito. Estamos quase no final do processo. A última etapa é alterar um pouco o aplicativo e o comportamento. Em vez do AWS API Gateway , queremos usar o Application Load Balancer . Vamos ver como conseguir isso no próximo capítulo.

ALB – Application Load Balancer na AWS

Criamos nosso aplicativo usando o AWS API Gateway. Neste capítulo, abordaremos como substituir o API Gateway pelo Application Load Balancer (ALB).

Primeiro, vamos ver como o balanceador de carga do aplicativo funciona em comparação com o API Gateway:

No balanceador de carga de aplicativos, mapeamos um caminho(s) específico(s) (por exemplo, /hello/ ) para um grupo de destino – um grupo de recursos, no nosso caso, a função Lambda .

Um grupo de destino pode ter apenas uma função do Lambda associada a ele. Sempre que o grupo de destino precisa responder, o balanceador de carga do aplicativo envia uma solicitação ao Lambda e a função precisa responder com um objeto de resposta. Assim como o API Gateway, o ALB lida com todas as solicitações HTTP(s).

Existem algumas diferenças entre o ALB e o API Gateway . Uma diferença principal é que o API Gateway suporta apenas HTTPS (SSL), enquanto o ALB suporta HTTP e HTTPS.

Mas, vamos ver alguns prós e contras do API Gateway:

Gateway de API:

Prós:

• Excelente segurança.
• É simples de implementar.
• É rápido para implantação e pronto para uso em um minuto.
• Escalabilidade e disponibilidade.

Contras:

• Pode se tornar bastante caro quando confrontado com alto tráfego.
• Requer um pouco mais de orquestração, o que adiciona um nível de dificuldade para os desenvolvedores.
• A degradação do desempenho, devido aos cenários da API, pode afetar a velocidade e a confiabilidade do aplicativo.

Vamos continuar criando um ALB e mudando para ele em vez de usar o API Gateway:

1. O que é ALB?

O balanceador de carga do aplicativo permite que o desenvolvedor configure e roteie o tráfego de entrada. É um recurso do “ Elastic Load Balancing”. Ele serve como o único ponto de contato para clientes, distribui o tráfego de aplicativos de entrada em vários destinos, como instâncias do EC2 em várias zonas.

2. Crie um Application Load Balancer usando a IU da AWS

Vamos criar nosso Application Load Balancer (ALB) por meio da interface do usuário no Amazon AWS. Faça login no Console AWS em “ Find services. ” digite “ EC2 ” e encontre “ Load Balancers. ”

Clique em “ Criar Load Balancer ”, em “ Application Load Balancer ”, escolha “ Criar ”. Para um nome, digite sua escolha, usamos “ amostra-alb”, escolha Esquema “ internet-facing ”, tipo de endereço IP ipv4.

Em “ Listeners ”, deixe como está – HTTP e porta 80. Pode ser configurado para HTTPS, embora você tenha que ter um domínio e confirmá-lo antes de poder usar HTTPS.

Zonas de disponibilidade – Para VPC , escolha a que você tem no menu suspenso e marque todas as “ Zonas de disponibilidade” :

Clique em “ Next Configure Security Settings ” para solicitar que você melhore a segurança do seu balanceador de carga. Clique em Avançar.

Em " Etapa 3.Configurar grupos de segurança ", em Atribuir um grupo de segurança, escolha "Criar um novo grupo de segurança". Prossiga em seguida clicando em “ Next: Configure Routing. “. Na etapa 4, configure-o conforme mostrado na captura de tela acima:

Clique em Avançar , Avançar e Criar .

Volte para os load balancers e copie o ARN conforme mostrado na captura de tela:

Agora temos que alterar nosso serverless.yml e remover a propriedade http do API Gateway. Na propriedade de eventos, remova a propriedade http e adicione uma propriedade alb. O objeto de função deve terminar assim:

 Olá:
  manipulador: handler.hello
  eventos:
    - alva:
        listenerArn: arn:aws:elasticloadbalancing:us-east-2:115129174008:listener/app/sample-alb/ae6e398a898c48e6/67ce6bf319d0513d
        prioridade: 1
        condições:
          caminho: /olá

Salve o arquivo e execute o comando para implantar o aplicativo
sls deploy -v

Após a implantação bem-sucedida, retorne aos AWS Load Balancers e encontre seu nome DNS, conforme mostrado na captura de tela:

Copie o nome DNS e digite o caminho /hello .

Deve funcionar e, eventualmente, oferecer a opção de baixar conteúdo :). Até agora, o balanceador de carga do aplicativo está funcionando perfeitamente, mas o aplicativo precisa retornar uma resposta adequada para nossos usuários finais. Para fazer isso, abra handler.js e substitua a instrução return pela abaixo:

 Retorna {
    código de status: 200,
    statusDescrição: "200 OK",
    cabeçalhos: {
        "Content-Type": "application/json"
    },
    isBase64Encoded: false,
    corpo: JSON.stringify(linhas)
}

A diferença do ALB é que a resposta deve incluir container statusDescription, headers e isBase64Encoded. Salve o arquivo e implante novamente, mas desta vez não todo o aplicativo, mas apenas a função que alteramos. Execute o comando abaixo:
sls deploy -f hello

Dessa forma, estamos definindo apenas a função hello para deploy. Após a implantação com sucesso, visite o nome DNS com o caminho novamente e você deverá ter uma resposta adequada!

Excelente! Agora substituímos o API Gateway pelo Application Load Balancer. O balanceador de carga do aplicativo é mais barato que o API Gateway e agora podemos estender nosso aplicativo para atender às nossas necessidades, especialmente se esperamos ter um tráfego maior.

Palavras finais

Criamos um aplicativo simples usando o Serverless Framework, AWS e BigQuery e abordamos seu uso principal. Serverless é o futuro, e é fácil lidar com um aplicativo com ele. Continue aprendendo e mergulhe na estrutura Serverless para explorar todas as suas funcionalidades e os segredos que ela possui. É também uma ferramenta bastante simples e conveniente.