Conteúdo


Implementar uma arquitetura baseada em microsserviço em Bluemix, Parte 2: Construir e implementar com o IBM Containers

Incluir um Gateway de API na frente de seus microsserviços

Comments

As arquiteturas de microsserviços permitem construir aplicativos em nuvem mais resilientes e escaláveis. Os aplicativos são particionados em vários serviços que se comunicam entre si, conforme necessário, através de APIs bem definidas.

Na Parte 1 desta série de tutoriais, o aplicativo de amostra foi implementado no Bluemix usando aplicativos CF. Neste tutorial, você irá construir e implementar o mesmo aplicativo, mas desta vez usará os IBM Containers.

Nosso aplicativo de amostra é construído usando o padrão de arquitetura de multisserviços e é um loja de e-commerce simples que vende armações para óculos. O aplicativo de amostra destina-se apenas à demo e não representa o código de qualidade de produção. No entanto, ele realiza showcase de um código base simples para explorar microsserviços.

Execute o aplicativo de amostraObtenha o código

O aplicativo de amostra consiste em dois microsserviços:

  • cat gerencia o catálogo de produtos
  • carrinho de compras gerencia um único carrinho de compras para cada sessão do navegador

No tutorial anterior, eles são acessados diretamente pela IU da web do aplicativo, que atuou como seu próprio Gateway API. Isso será bom se o único cliente do aplicativo baseado em microsserviço for a interface com o usuário, porém um Gateway de API separado será necessário se você quiser suportar outros clientes (por exemplo, uma CLI) para o aplicativo. Neste tutorial, você incluirá um Gateway de API na frente de seus microsserviços.

Software necessário para este tutorial

Conteinerizando os microsserviços

Para implementar os microsserviços cat e carrinho de compras usando o IBM Containers, é necessário fornecer Dockerfiles que definem imagens de contêiner em execução nos mesmos servidores Python Flask que você executou como Aplicativos CF na Parte 1. Um Dockerfile bastante básico que simplesmente executa um aplicativo Flask seria algo parecido com isto:

FROM phusion/baseimage

ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update -qq && \
    apt-get install -y -q --no-install-recommends \
    python2.7 python-pip build-essential python-dev

RUN pip install Flask Flask-Cache pymongo

# application source code including static files, templates, etc
ADD src /app/src

EXPOSE 5000

ENTRYPOINT ["python", "-u", "/app/src/app.py"]

Um Dockerfile como esse funcionará bem para ambos os microsserviços cat e carrinho de compras, portanto, tudo o que você precisa fazer para executá-los no Bluemix é:

  1. Construir as duas imagens e enviá-las por push para um registro do Bluemix.
  2. Inicie um grupo de contêineres para cada imagem.
  3. Inclua uma rota (maproute) no GoRouter para cada um dos grupos de contêineres.

Os comandos CLI para fazer isso com o microsserviço cat se parecem com isto:

# Build the cat image
docker build -t cat:v1 .
docker tag -f cat:v1 registry.ng.bluemix.net/davetropeano/cat:v1
docker push registry.ng.bluemix.net/davetropeano/cat:v1

# Start the Catalog microservice instances
cf ic group create --name cat_microservice -p 5000 -m 256 \
  -e "MONGODB_URI=$MONGODB_URI" \
  --min 1 --max 2 --desired 1 registry.ng.bluemix.net/davetropeano/cat:v1

# Map the Catalog route to the Catalog microservice group
cf ic route map --hostname cat-ic --domain mybluemix.net cat_microservice

Como é possível ver, use a CLI Docker simples para construir e enviar por push a imagem. Em seguida, crie um grupo de contêineres usando a CLI do IBM Containers cf ic create group . Conforme descrito na Parte 1, o microsserviço cat usa um servidor de banco de dados MongoDB para armazenar o catálogo de óculos, o local do qual você simplesmente passa para o aplicativo com a variável de ambiente MONGODB_URI. Finalmente, use o comando cf ic route map para expor o microsserviço em cat-ic.mybluemix.net.

Para confirmar se o microsserviço está funcionando, é possível obter vantagem do fato de que ambos os microsserviços cat e carrinho de compras suportam uma URL __health__ que retornará "1" se estes estiverem em execução. Portanto, para o microsserviço cat, é possível verificá-lo desta maneira:

% curl cat-ic.mybluemix.net/cat/__health__
1

Para iniciar o microsserviço carrinho de compras, use o mesmo conjunto de comandos (única mudança "cat" para "carrinho de compras" em todos os lugares que ele aparecer no script). O microsserviço carrinho de compras será executado em cart-ic.mybluemix.net. Novamente, confirme se ele está sendo executado desta maneira:

% curl cart-ic.mybluemix.net/cart/__health__
1

Observe que você está expondo os microsserviços cat e carrinho de compras usando rotas de DNS públicas, mesmo que eles nunca sejam usados​por clientes externos. Em uma melhor implementação (que nós vamos cobrir em um tutorial futuro), você poderia criar esses IPs privados que ficam visíveis somente para clientes internos dentro do sistema/aplicativo de microsserviços.

O Gateway de API

Com os dois microsserviços funcionando, agora é necessário ter um Gateway de API na frente deles. Para isso, você usará o Nginx (um servidor proxy reverso de HTTP disponível) com uma configuração estática simples como esta:

server {
    listen 80;
    error_log /var/log/nginx/error.log;
    sendfile off;

    location /cat {
        proxy_pass http://cat-ic.mybluemix.net;
    }

    location /cart {
        proxy_pass http://cart-ic.mybluemix.net;
    }
}

Como você pode ver, o Gateway de API é um servidor proxy reverso simples que encaminha solicitações para o microsserviço cat ou carrinho de compras, dependendo do primeiro segmento do caminho da URL.

Esse Gateway de API simples não tem os benefícios de registo de serviço dinâmico e de implementação (discutiremos isso na Parte 3 desta série), mas ele fornece benefícios importantes de uma arquitetura baseada em microsserviços que divide o aplicativo em componentes implementados separadamente sem afetar os clientes.

Para executar o Gateway de API, basta implementar uma imagem de contêiner Nginx usando a configuração acima. O Dockerfile do Gatway de API se parece com isto:

FROM phusion/baseimage

RUN apt-get update
RUN apt-get -y install nginx curl

RUN rm -f /etc/nginx/sites-enabled/default
ADD nginx.conf /etc/nginx/conf.d/nginx.conf
ADD run-nginx.sh /tmp/run-nginx.sh

RUN ln -sf /dev/stdout /var/log/nginx/access.log
RUN ln -sf /dev/stderr /var/log/nginx/error.log

EXPOSE 80 443

CMD ["/tmp/run-nginx.sh"]

Observe que você executa um script (run-nginx.sh) em vez do Nginx diretamente. Faça isso para que possa pausar até que os microsserviços cat e carrinho de compras sejam executados:

#!/bin/bash
up=`curl -s http://cat-ic.mybluemix.net/cat/__health__`
until [ "$up" = "1" ]; do
    echo "waiting for cat server ..."
    sleep 10s
    up=`curl -s http://cat-ic.mybluemix.net/cat/__health__`
done

up=`curl -s http://cart-ic.mybluemix.net/cart/__health__`
until [ "$up" = "1" ]; do
    echo "waiting for cart server ..."
    sleep 10s
    up=`curl -s http://cart-ic.mybluemix.net/cart/__health__`
done

echo "cat and cart servers are running."

nginx -g "daemon off;"

while true; do
    echo "nginx returned, going to sleep ..."
    sleep 1d
done

Os comandos para iniciar o Gateway de API são basicamente os mesmos para os microsserviços. Ou seja, inicie um grupo de contêineres para a imagem Nginx e depois inclua uma rota para o grupo no GoRouter. Você mapeará o Gateway de API para a rota shop-ic.mybluemix.net.

Aqui está a figura completa do aplicativo em execução:

Microservice containers with static API Gateway config on Bluemix
Microservice containers with static API Gateway config on Bluemix

Com o Gateway de API funcionando, agora você deverá ser capaz de conectar-se a um dos microsserviços por meio do servidor gateway em shop-ic.mybluemix.net:

% curl shop-ic.mybluemix.net/cat/__health__
1
% curl shop-ic.mybluemix.net/cart/__health__
1

O cliente de IU

Como a interface com o usuário da web é apenas um dos muitos possíveis clientes deste aplicativo baseado em microsserviços (por exemplo, também é possível ter um cliente móvel ou um cliente CLI), torna-se irrelevante o modo como você implementa o servidor de UI para este tutorial. A interface com o usuário, como qualquer outro cliente, fará interface com os microsserviços exclusivamente usando a API REST fornecida pelo Gateway de API.

Para manter as coisas simples, vamos reutilizar a IU da Parte 1, somente com as duas variáveis de ambiente CAT_ENTRYPOINT e CART_ENTRYPOINT configuradas para o mesmo valor: http://shop-ic.mybluemix.net. Em outras palavras, você irá ignorar o fato de que a interface com o usuário foi projetada para saber sobre os microserviços individuais, e simplesmente instruí-la a acessar ambos através do Gateway de API

Uma vez que este tutorial usa o IBM Containers, em vez de executar a interface com o usuário como um Aplicativo CF, também iremos implementá-lo como um contêiner neste momento. O processo para criar a imagem e implementar o contêiner de IU é essencialmente o mesmo para os microsserviços cat e carrinho de compras. De fato, uma vez que a IU também é um aplicativo Flask, o Dockerfile é exatamente igual àquele que você usou para cat e carrinho de compras.

Aqui está o script para construir e executar a IU:

# Build the UI image
docker build -t shop_ui:v1 .
docker tag -f shop_ui:v1 registry.ng.bluemix.net/davetropeano/shop_ui:v1
docker push registry.ng.bluemix.net/davetropeano/shop_ui:v1

# Start the UI instances
cf ic group create --name shop_ui -p 5000 -m 256 \
  -e "CAT_ENTRYPOINT=http://shop-ic.mybluemix.net" \
  -e "CART_ENTRYPOINT=http://shop-ic.mybluemix.net" \
  --min 1 --max 2 --desired 1 registry.ng.bluemix.net/davetropeano/shop_ui:v1

# Map the UI route to the shop UI group
cf ic route map --hostname glasses4u-ic --domain mybluemix.net shop_ui

Para ver a versão do aplicativo em execução, clique no botão "Executar o aplicativo de amostra", no início deste tutorial.

O catálogo de óculos exibido é gerenciado pelo microsserviço cat. Para confirmar se o microsserviço carrinho de compras também está funcionando, navegue até um produto específico e clique emIncluir no carrinho de compras (isso será postado no microsserviço carrinho de compras); isso deverá resultar em uma entrada aparecendo no carrinho de compras (o canto superiordireito da tela).

Para obter o código-fonte para esse aplicativo , clique no botão "Obter o código" no início deste tutorial.

Conclusão

Este tutorial mostrou como um simples aplicativo baseado em microsserviço, apresentado anteriormente naParte 1, pode ser implementado usando o IBM Containers. Nós também incluímos um outro componente importante de um sistema baseado em microsserviço: um Gateway de API. Nosso Gateway de API foi implementado de uma forma muito simples e estática, algo que não seria típico em um sistema baseado em microsserviço totalmente desenvolvido.

Na Parte 3, estenderemos ainda mais o nosso exemplo para usar o registro de serviço dinâmico e a descoberta, fornecendo um Gateway de API que seja dinamicamente configurado como instâncias de ir e vir do microsserviço.


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Cloud computing
ArticleID=1026250
ArticleTitle=Implementar uma arquitetura baseada em microsserviço em Bluemix, Parte 2: Construir e implementar com o IBM Containers
publish-date=01262016