4Linux no DevCamp 2019: Service Mesh, Funções de Alta-Ordem e Deep Learning

A 4Linux participou do DevCamp 2019 como patrocinadora e levamos o Lucas Ricciardi de Salles – um de nossos desenvolvedores – para participar do evento assistindo as palestras e assim compartilhar aqui no blog todo o conhecimento adquirido durante o evento.

# Service Mesh e Sidecars com Istio e Envoy #

A primeira palesta que assisti após a introdução foi uma palestra sobre Service Mesh, uma camada de infraestrutura dedicada à fazer a comunicação entre serviços segura, rápida e confiável. Mais especificamente o palestrante falou sobre Istio e Envoy que são implementações desses serviços. Das partes mais interessantes vistas nessa palestra estão:

– Stack Trace de Microsserviços

Quando trabalhamos com microsserviços, fica mais difícil de se rastrear o caminho por onde uma requisição passa, o que dificulta muito o trabalho de se rastrear bugs por exemplo. Utilizando uma ferramenta como Jaeger, que faz parte do ecossistema instalado pelo Istio, o desenvolvedor consegue rastrear esse fluxo por entre os microsserviços.

– Técnicas avançadas de deploy

O deploy de microsserviços é especialmente importante e ao mesmo tempo desafiador para o desenvolvedor, daí a analogia de que fazer um deploy em microsserviços é como trocar um pneu com o carro andando. As técnicas avançadas de deploy (blue-green, canary, etc) se reverem as metodologias em que o serviço antigo é gradualmente e/ou repentinamente substituído pela versão mais nova. Isso é especialmente interessante pois é muito comum que as falhas comecem a surgir num ambiente de produção apenas, e a possibilidade de uma transição gradual de uma versão a outra ajuda o desenvolvedor a se antecipar aos futuros problemas.

#Higher Order Functions e Functional Interfaces#

Aqui o palestrante falou sobre funções de Alta-Ordem, que por definição, são funções que atendem a pelo menos um dos seguintes requisitos:

– Recebe como parâmetro ao menos uma função;
– Retorna uma função;

Este tipo de técnica é interessante para construção de interfaces que oferecem ao usuário um grande poder de customização da API ao mesmo tempo que mantém uma interface uniforme. Assim a API pode evoluir internamente sem a necessidade de que sua interface mude.

Um exemplo seria o seguinte servidor hipotético:

def create_server(host, port, debug):

  opts = {
    'host': host,
    'port': port,
    'debug': debug
  }

  return Server(opts)

create_server('0.0.0.0', 5000, False)

Para que não sejamos forçados a passar os argumentos, deixamos eles com valores default.

def create_server(host='0.0.0.0', port=5000, debug=False):

  opts = {
    'host': host,
    'port': port,
    'debug': debug
  }

  return Server(opts)

create_server('0.0.0.0', 5000, False)

Mas ao introduzirmos um novo parâmetro de configuração, quebramos a interface da função.

def create_server(read_max_timeout, host='0.0.0.0', port=5000, debug=False):

  opts = {
    'host': host,
    'port': port,
    'debug': debug
  }

  return Server(opts)

create_server() # quebrou aqui

Se reescrevemos usando funções de Alta-Classe podemos utilizar a seguinte sintaxe:

def create_server(*args):

  # deixamos aqui as opções default
  opts = {
    'host': '0.0.0.0',
    'port': 5000,
    'debug': False,
    'read_max_timeout': 1000,
    'write_max_timeout': 1000
  }

  # damos a oportunidade do usuários configurar o sistema aqui
  for fn in args:
    opts = fn(opts)

  return Server(opts)

# E utilizamos da seguinte forma
def with_host(host):
  def wrapper(opts):
    opts.update({
      'host': host
    })
    return opts
  return wrapper

def with_port(port):
  def wrapper(opts):
    opts.update({
      'port': port
    })
    return opts
  return wrapper

create_server(
  with_host('0.0.0.0'),
  with_port(5000)
) 

No exemplo acima, passamos funções que irão configurar o servidor antes que ele seja iniciado, concentrando o único ponto de mutabilidade no momento da criação do servidor e mantendo uma interface uniforme de maneira que fique fácil de se customizar.

Além disso, funções de Alta-Classe são a base para a técnica de Currying, muito popular no ramo de programação funcional e muito utilizado na área de Data Science para criação de mappings.

# Sorria, você está sendo observado #

Aqui a palestra foi sobre Observables, uma tecnologia utilizada pela framework Angular para passagem de mensagens entre *publishers* e *subscribers*, ou seja, uma implementação do Observer Pattern.

A técnica se baseia na criação de gatilhos que irão agir como fonte de mudança/emissão de informação para outras partes do sistema que irão reagir à esses gatilhos. Exemplos de Observables são as requisições HTTP que fazemos às APIs, cliques de botões, conquistas que os usuários desbloqueiam (em sistemas de gamification) e a grande vantagem do observable é o desacoplamento entre a causa e a consequência.

Outro ponto interessante da palestra foi a biblioteca RxJS que permite a criação de pipes nos Observables. Isto expande ainda mais o leque de possibilidades ao desenvolvedor dando a ele o controle de como, quando e até mesmo com que frequência a informação se propaga dentro do sistema.

# Implementando models de Deep Learning em cluster Kubernetes #

Machine Learning é um tópico que está muito em alta hoje em dia, e aqui a palestrante demonstrou uma parte muito interessante e que muito gente tem dúvida. Depois que treinamos nossos modelos de Machine Learning, como podemos disponibilizar eles para a utilização ?

A palestra começou com a demonstração do conceito de Deep Learning, que nada mais são redes neurais com muitas camadas ocultas. A premissa básica aqui é, por exemplo, como reconhecer um rosto em uma foto ? Primeiramente identificamos se há um par de olhos, depois se há um nariz, depois uma boca e assim vai. Quanto mais características que um rosto tem identificarmos, mais provável será de aquilo se tratar de um rosto. Uma rede neural profunda identifica essas características individuais para tirar uma conclusão do todo.

Existem diversos modelos já bem estudados para detecção de imagens, como por exemplo ResNet e MobileNet, mas inevitavelmente todos ainda exigem uma quantidade relativamente grande de cálculos para realizar uma previsão em um tempo hábil, portanto ainda há a necessidade de um cluster aonde esse algoritmo rode. Como podemos então criar um cluster somente para o algoritmo ?

E a resposta não poderia ser mais simples e bonita, utilizando Serverless ! Ao realizar o deploy do seu modelo, por debaixo de uma API simples por exemplo, em um container serverless você terá acesso à seu algoritmo como uma espécie de microservice. Ele terá o cluster dedicado para rodar seus cálculos e estará isolado e independente da aplicação que irá consumi-ló.

CURSOSCONSULTORIA    CONTATO