Nestjs, Heroku e Axway Amplify

O Axway Amplify permite o gerenciamento e governança de APIs e integração de ativos em todos os ambientes, nuvens e API Gateways (Axway e não Axway).

Com o Amplify, as equipes têm um hub centralizado para descobrir APIs existentes, selecionar e compartilhar suas APIs, integrar consumidores e assinar APIs para consumo.

O Amplify Central permite que você aumente a visibilidade e o consumo de suas APIs ao fazer parte do ecossistema interno e de parceiros. 

Principais Vantagens

Autonomia a equipes

O Amplify é uma camada de gerenciamento centralizada, com isso facilita a padronização em elementos comuns onde todos podem usar, mantendo a capacidade de construir rapidamente e atender às necessidades dos clientes.

Reutilização

Conforme as empresas vão crescendo e aumentando o número de apis criadas, é difícil para que os desenvolvedores encontrem a API que necessitam. Com o catálogo Amplify é possível encontrar as soluções já existentes evitando duplicações

Insights

Você pode identificar quais APIs são bem-sucedidas e estão crescendo, quais precisam de modificações ou desativamento.

A seguir, para demonstrar o uso do Axway Amplify, na prática, iremos desenvolver uma api que efetua um Crud simples, onde faremos o deploy no heroku e o gerenciamento na plataforma Axway Amplify.

Principais Vantagens

Autonomia a equipes

O Amplify é uma camada de gerenciamento centralizada, que facilita a padronização em elementos comuns onde todos podem usar, mantendo a capacidade de construir rapidamente e atender às necessidades dos clientes.

Reutilização

Conforme as empresas vão crescendo e aumentando o número de APIs criadas, torna-se difícil para  os desenvolvedores encontrarem a API que necessitam. Com o catálogo Amplify é possível encontrar as soluções já existentes evitando duplicações

Insights

Você pode identificar quais APIs são bem-sucedidas e estão crescendo, quais precisam de modificações ou desativamento.

A seguir, para demonstrar o uso do Axway Amplify na prática, iremos desenvolver uma API que efetua um Crud simples, onde faremos o deploy no Heroku e o gerenciamento na plataforma Axway Amplify.

Criando a API em NodeJS

Vamos criar uma API que efetua um crud simples onde podemos fazer a manipulação de carros.

Para este projeto, utilizaremos o Nodejs, e também faremos a instalação de um poderoso framework, o NestJS ,uma ferramenta Open Source que irá acelerar o desenvolvimento da API.

Setup do projeto

1. Certifique-se de ter o Node instalado em sua versão TLS de preferência. Instale a CLI do framework Nestjs de forma global, executando o seguinte comando:

npm i -g @nestjs/cli

2. Rode o seguinte comando para criar uma aplicação em Nestjs:

nest new api-nest-heroku-amplify

3. Agora temos uma arquitetura pronta para o desenvolvimento da API. Execute o seguinte comando para iniciar a aplicação:

npm start:dev

4. Abra o navegador e a aplicação estará disponível em http://locahost:3000/:

Mensagem de hello world

Criando a API

1. Crie uma pasta chamada cars, ela será o módulo onde criaremos todos os arquivos responsáveis pela manipulação de carros.

2. Crie um arquivo chamado cars.controller.ts em src/cars e adicione o conseguinte código:

import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Post,
  Put,
} from '@nestjs/common';
import { Cars } from './cars.model';
import { CarsService } from './cars.service';
@Controller('cars')
export class CarsController {
  constructor(private carsService: CarsService) {}
  @Get()
  obterTodos(): Cars[] {
    return this.carsService.getAll();
  }
  @Get(':id')
  obterUm(@Param() params): Cars {
    return this.carsService.getOne(params.id);
  }
  @Post()
  criar(@Body() cars: Cars) {
    this.carsService.create(cars);
  }
  @Put()
  alterar(@Body() cars: Cars): Cars {
    return this.carsService.update(cars);
  }
  @Delete(':id')
  apagar(@Param() params) {
    this.carsService.delete(params.id);
  }
}

2. Crie um arquivo chamado cars.service.ts em src/cars e adicione o seguinte código:

import { Injectable } from '@nestjs/common';
import { Cars } from './cars.model';
@Injectable()
export class CarsService {
  cars: Cars[] = [
    new Cars(
      'Ferrari F8',
      'Ferrari',
      '<https://www.carlogos.org/car-logos/ferrari-logo-750x1100.png>',
    ),
    new Cars(
      'Lamborghini Aventador',
      'Lamborghini',
      '<https://www.carlogos.org/car-logos/lamborghini-logo-1000x1100.png>',
    ),
    new Cars(
      'Porsche 911',
      'Porsche',
      '<https://www.carlogos.org/car-logos/porsche-logo-2100x1100.png>',
    ),
  ];
  getAll(): Cars[] {
    return this.cars;
  }
  getOne(id: number): Cars {
    return this.cars[0];
  }
  create(cars: Cars) {
    this.cars.push(cars);
  }
  update(cars: Cars): Cars {
    return cars;
  }
  delete(id: number) {
    this.cars.pop();
  }
}

3. Agora vamos adicionar o model Cars. Crie um arquivo chamado cars.model.ts em src/cars com o código abaixo:

export class Cars {
  id: number;
  description: string;
  brand: string;
  logo: string;
  constructor(description: string, brand: string, logo: string) {
    this.description = description;
    this.brand = brand;
    this.logo = logo;
  }
}

4. Adicione o module CarsModule e crie um arquivo chamado cars.module.ts com o seguinte código:

import { Module } from '@nestjs/common';
import { CarsController } from './cars.controller';
import { CarsService } from './cars.service';
@Module({
  imports: [],
  controllers: [CarsController],
  providers: [CarsService],
})
export class CarsModule {}

5. Em src/app.module.ts importe o modulo cars da seguinte maneira:

import { Module } from '@nestjs/common';
import { CarsModule } from './cars/cars.module';
@Module({
  imports: [CarsModule],
})
export class AppModule {}

Configurando o Swagger

1. Para fazer a instalação do módulo do Swagger, execute o seguinte comando:

npm install @nestjs/swagger

2. Adicione a seguinte configuração no arquivo main.ts:

import { NestFactory } from '@nestjs/core';
import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
import { AppModule } from './app.module';
async function bootstrap() {
  const app = await NestFactory.create(AppModule, { cors: true });
  const config = new DocumentBuilder()
    .setTitle('Cars API')
    .setDescription('The cars API description')
    .setVersion('1.0')
    .addTag('cars')
    .build();
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);
  await app.listen(Number.parseInt(`${process.env.PORT}`) || 3000);
}
bootstrap();

3. Agora o Swagger da Api estará configurado e disponível em http://localhost:3000/api, com todos os endpoints que criamos anteriormente.

Agora temos uma API onde podemos listar, adicionar, atualizar e deletar carros, com o Swagger da API disponível.

Realizando o deploy no Heroku

1. Crie uma aplicação no Heroku, seguindo os seguintes passos:

1.1. Faça o login no heroku;

1.2. Navegue até a dashboard;

1.3. Clique em new;

1.4. Selecione Create new app;

Configurando a Aplicação

1. Com a aplicação no Heroku criada, vamos configurar nossa aplicação para realizar o processo de deploy. Na raiz do projeto, adicione um arquivo chamado Procfile, com a seguinte configuração:

web: npm run start:prod

2. Volte para a dashboard da aplicação no heroku. Agora vamos adicionar variáveis de ambiente que serão necessárias para rodar o build da nossa aplicação:

2.1. Navegue até a dashboard;

2.2. Selecione a aplicação que acabamos de criar;

2.3. Clique em settings;

2.4. Selecione Reveal Config Vars;

2.5. Adicione as seguintes variáveis de ambiente.

Escreva a legenda e créditos da imagem

Deploy da aplicação

1. Agora vamos fazer o deploy da aplicação de fato, caso você ainda não tenha feito o login com o comando heroku login . Certifique-se de ter a CLI do heroku instalada, caso o contrário faça a instalação.

2. Rode o comando git add .;

3. Rode o comando git commit -m "add aplication nest";

4. Agora execute o comando git push heroku master. Será iniciado o processo de deploy da nossa aplicação.

5. Aguarde o processo de deploy ser concluído, na dashboard selecione a aplicação criada e clique em open app.

Agora nossa aplicação está no ar, onde podemos acessá-la de qualquer lugar. 

Gerenciando a API com o Axway Amplify

Agora com nossa aplicação disponível no Heroku e com o URL de produção disponível, vamos fazer o registro no Axway amplify, onde será possível fazer todo o gerenciamento da nossa API.

Para obter acesso gratuito ao Axway Amplify por um período de teste, acesse a plataforma Amplify e inscreva-se.

Registrando nossa API

1. Caso já possua uma conta na plataforma da Axway com os serviços do Axway Amplify disponível, faça seu login. Na tela inicial, clique em central.

2. No menu lateral, selecione a opção API Proxies.

2. Coloque a URL da nossa API no Heroku com /api-json no final. Clique em Fetch from URL.

3. Com nossa API adicionada com sucesso, clique em Next.

4. Na tela Resgister an API, preencha os dados do formulário e clique em Save.

5. Nossa API foi registrada com sucesso clique em Go to API proxies.

6. Volte para API Proxies e, com a proxie criada, em Test Runtime, clique em Deploy:

7. Agora temos um Gateway de APIs configurado com a URL disponível. 

8. Em API Proxies > Test Methods estará disponível o Swagger da nossa API, onde é possível testarmos todos os endpoints.

Configurando o API Catalog

1. Em API Proxies, clique em Add to Catalog, preencha os dados do formulário e clique em Add to Catalog:

2. Clique na opção do menu Explore Catalog. Agora é possível, metrificar o uso da API, fazer o acompanhamento de tráfego e numero de requisições.

Com isso, passamos pelo ciclo completo do desenvolvimento de uma API desde da criação ao gerenciamento, adicionando no Axway Amplify e explorando todas as vantagens da plataforma.

Este artigo foi escrito por wellington santos de souza e publicado originalmente em Prensa.li.