Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Computação Serverless: Conceitos, Aplicações e Desafios

Computação Serverless: Conceitos, Aplicações e Desafios

Slides da apresentação do Minicurso sobre Computação Serverless apresentado durante a conferência SBRC em 2020. Um trabalho em parceria da UFMG com UFV. Os slides representam o artigo disponível em:
https://sol.sbc.org.br/livros/index.php/sbc/catalog/download/50/232/469-1?inline=1
Os slides apresentam os conceitos, os desafios, a história, as linhas de pesquisa e um tutorial de como usar a ferramenta opensource OpenFaaS.

B1412c9ed55333c1df561f64dfad69d3?s=128

Gustavo Pantuza

April 02, 2021
Tweet

Transcript

  1. Computação Serverless: Conceitos, Aplicações e Desafios André G. Vieira¹, Gustavo

    Pantuza¹, Jean H. F. Freire¹, Lucas F. S. Duarte², Racyus D. G. Pacífico¹, Marcos A. M. Vieira¹, Luiz F. M. Vieira¹, José A. M. Nacif² ¹Universidade Federal de Minas Gerais (UFMG) - Belo Horizonte, MG - Brasil ²Universidade Federal de Viçosa (UFV) - Florestal, MG - Brasil
  2. O Minicurso • Introdução • Histórico • Potencial • Computação

    Serverless • Plataformas 2 • Pesquisa • Limitações do modelo • Tutorial OpenFass • Conclusões
  3. Introdução • Definição 3 Retirar do desenvolvedor a responsabilidade de

    configurar recursos computacionais, deixando apenas a escrita das funções que compõem o artefato desenvolvido [Hendrickson et al. 2016]
  4. Introdução • 67% dos gastos de infraestrutura em tecnologias em

    nuvem ◦ [Castro et al. 2019] • Pagar apenas pelo que se utiliza • Escalabilidade • Precisão de cobrança • Desacopla a plataforma 4
  5. Histórico • Centros de dados (datacenters) • Múltiplos clientes/aplicações •

    Máquinas virtuais ◦ Compartilhamento de recursos ◦ Isolamento entre sistemas operacionais 5
  6. Histórico • IaaS (Infrastructure as a service) - Infraestrutura como

    serviço 6 2006 2010 2012
  7. Histórico • PaaS (platform as a service) - Plataforma como

    serviço 7 2006 2008
  8. Histórico • Contêineres ◦ Isolamento ◦ Reprodutibilidade ◦ Automação ◦

    Imagens pequenas 8 2013
  9. Histórico • AWS Lambda ◦ primeiro serverless ◦ Funções ◦

    Linguagem ◦ Chamada HTTP 9 2014
  10. Computação em nuvem moderna • +10 anos • Escalabilidade •

    Carga operacional • Complexidade [Jonas et al. 2019] 10
  11. Computação em nuvem moderna • Serverless ◦ Abstração ◦ Contabilidade

    ◦ Simplicidade 11
  12. Computação em nuvem moderna • Serverless ◦ Estima-se 7.72 bilhões

    de dólares até 2021 ▪ [Castro et al. 2019] ◦ CNCF - Cloud Native Computing Foundation 12
  13. Usos da computação serverless • Serverless ◦ Funções 13 •

    Nuvem convencional ◦ Funções ◦ Plataforma ◦ Infraestrutura
  14. Usos da computação serverless • Tarefas Periódicas • Eventos •

    Fila / Mensageria • Tempo real • Notificações 14 • Ferramentas analíticas • Serviços sob demanda • Funções paralelas • Internet das coisas
  15. Potenciais computação serverless • Depuração orientada a custo financeiro •

    Decomposição de sistemas legados • Compartilhamento de ambientes de execução [Hendrickson et al] 15
  16. Potenciais computação serverless • Minimiza curva de aprendizado • Agilidade

    em usar serviços em Nuvem • Reduz custos • Aumenta granularidade de custo 16
  17. Paradigma “Como Serviço” • PaaS • IaaS • SaaS 17

    “O paradigma de disponibilização de aplicações denominado ‘como serviço’ tem essa terminologia devido à ocultação de aspectos do usuário ” [Wang et al. 2018]
  18. Funções como serviço • FaaS ◦ Functions as a Service

    ◦ Funções como Serviço 18 Ao invés de se provisionar infraestrutura ou a própria plataforma na qual o código é executado, se fornece uma estrutura que irá executar uma unidade de código: Uma Função
  19. Funções como serviço • FaaS ◦ Código da função ◦

    Lista de bibliotecas ◦ Como deve escalar ◦ Conectividade URI 19
  20. Evolução • Bare-metal: ◦ Cada aplicação roda diretamente sob uma

    máquina física ◦ Apenas sistema operacional como intermediário ◦ Vantagens apresentadas no desempenho da aplicação; ◦ Alto custo e a dificuldade de prover e gerenciar. 20
  21. Evolução • virtualização: ◦ Hypervisor: camada extra sobre o sistema

    operacional ◦ Vários sistemas operacionais de maneira isolada ◦ Maior flexibilidade ◦ Administração mais simples ◦ Custos de implantação são reduzidos. 21
  22. Evolução • Contêineres: ◦ Sistema de virtualização em nível de

    sistema operacional ◦ Aplicações executadas de forma isoladas em espaço de usuário ◦ Funções básicas do sistema operacional são compartilhadas ◦ Mais enxuto e eficiente que as máquinas virtuais. 22
  23. Evolução 23

  24. Comunicação em contêineres • Série de drivers de redes nativos;

    • Escolhidos com base nos requisitos da aplicação; ◦ Host ◦ Bridge ◦ Overlay ◦ MACVLAN ◦ None 24
  25. Modelo Serverless • Sem servidor mesmo? • Não dispensa por

    completo o uso de servidores; • Retira do desenvolvedor a responsabilidade de configurar o recurso computacional; • Apenas a escrita das funções que compõem o artefato desenvolvido. 25
  26. Modelo Serverless • Deixa a cargo do provedor de serviço

    da aplicação a infra-estrutura computacional; • Desde a disponibilização básica até a escalabilidade • Nenhum membro da equipe possui acesso a infraestrutura, apenas à aplicação em si. 26
  27. Modelo Serverless • Inerentemente sem estado; • Sistemas que necessitem

    de dados persistentes devem acessá-los de outra fonte; • Armazenamento-como-serviço; • Tarefas de gerenciamento, manutenção e segurança deslocadas para a plataforma; • Preço e vendor lock-in. 27
  28. Modelo Serverless • Provedores se utilizam de contêineres; ◦ Prover

    isolamento entre as funções; ◦ Modelo rápido de escala. • Controlados via orquestradores; ◦ Docker Swarm; ◦ Kubernetes. • Executados sobre máquinas tradicionais; • Ocultos do desenvolvedor da aplicação; • Não há servidores visíveis para o usuário final. 28
  29. Modelo Serverless • Responsabilidades da plataforma: ◦ Fornecer uma localidade

    onde o serviço é disponibilizado (URL) ◦ Escalabilidade do serviço ◦ Maneiras de se inserir, modificar e monitorar o uso da função ◦ Segurança básica(DDOoS, virus) • Responsabilidades do desenvolvedor: ◦ Atenção ao ecossistema ◦ Conhecimento da plataforma utilizada ◦ Segurança: informações expostas, níveis de acesso e configuração de permissões. 29
  30. Modelo Serverless • Precificação: ◦ Funções cobradas por invocação; ◦

    Sem custos por recursos não utilizados ou ociosos. • Segurança: ◦ Desenvolvedor ainda possui responsabilidades; ◦ Modifica como deve ser realizado ou mesmo insere novos desafios. 30
  31. Serverful • Abordagem tradicional dos sistemas em nuvem. • Desenvolvedor

    aluga a infraestrutura • Configuração dos pacotes e serviços necessários à aplicação • Acesso direto a máquina virtual ou contêiner • Pagamento realizado por slots de tempo 31
  32. Serverful x Serverless 32 Escalabilidade Serverful É necessário subir novas

    máquinas e/ou contêineres caso a demanda aumente. Em caso de baixa demanda, recursos são desperdiçados. Serverless Escala automaticamente, não é necessário nenhuma ação por parte do desenvolvedor da aplicação
  33. Serverful x Serverless 33 Manutenção Serverful Requer manutenção, é preciso

    instalar, monitorar e manter atualizados os softwares necessários a aplicação Serverless A manutenção fica a cargo do provedor do serviço. O desenvolvedor apenas escreve e implanta código usando as ferramentas fornecidas
  34. Serverful x Serverless 34 Custo Serverful pago por tempo para

    manter o servidor disponível mesmo que não esteja sendo usado. Serverless É pago por invocação, caso não ocorra o uso não existe cobrança.
  35. Serverful x Serverless 35 Implantação Serverful Permite implantar serviços diretamente.

    É necessário logar na máquina e rodar o serviço e suas dependências. Serverless Baseado em eventos, o desenvolvedor implanta uma função e ela é executada como resposta a um evento que ocorre no sistema.
  36. Plataformas 36

  37. Plataformas 37

  38. AWS Lambda • Lançado em 2014 • Altamente integrada a

    outros serviços AWS • Firecracker • linguagens suportadas ◦ Java ◦ GO ◦ PowerShell ◦ JavaScript ◦ C# ◦ Python ◦ Ruby 38
  39. Azure Functions • Lançado em 2016 • Altamente integrada a

    outros serviços Azure • Durable Functions • linguagens suportadas ◦ C# ◦ JavaScript ◦ F# ◦ Java ◦ PowerShell ◦ Python ◦ TypeScript 39
  40. Cloud Functions • Lançado em 2016 • Altamente integrada a

    outros serviços Google • linguagens suportadas ◦ JavaScript ◦ Go ◦ Python 40
  41. OpenFaaS • Plataforma de código aberto (licença MIT); • Funções

    são executadas em contêineres individuais; • Escalabilidade baseada no número de requisições; • Suporta várias linguagens de programação; • Possui uma interface gráfica amigável; • É um framework portátil. 41
  42. Arquitetura OpenFaaS 42

  43. • Camada 4 (API Gateway): ◦ Interliga todos os módulos

    do framework; ◦ Gerencia os mecanismos de comunicação; ◦ Mensagens enviadas através do protocolo HTTP; ◦ Implementa mecanismos de segurança; ◦ Utilizado pela GUI interativa. 43 Arquitetura OpenFaaS
  44. • Camada 3 (Watchdog e Prometheus): ◦ Interface entre as

    funções e o mundo externo; ◦ A API envia os dados de entrada para o Watchdog; ◦ A função recebe os dados e produz as respostas; ◦ O Watchdog envia os dados de volta para a API; ◦ Os dados são apresentados ao usuário final; ◦ Métricas de utilização (Prometheus). 44 Arquitetura OpenFaaS
  45. • Camada 3 (Comunicação entre API e função): 45 Arquitetura

    OpenFaaS
  46. • Camada 2 (Orquestração): ◦ Organiza e gerencia instâncias de

    contêineres; ◦ Permite organização horizontal dos contêineres; ◦ Fácil inclusão de novos servidores (nós); ◦ Permite rápida adaptação de recursos; ◦ Google Kubernetes (K8s); ◦ Docker Swarm. 46 Arquitetura OpenFaaS
  47. • Camada 1 (Docker): ◦ Sistema de virtualização robusto; ◦

    Recursos compartilhados com o hospedeiro; ◦ Rápidos e leves quando comparados com VMs; ◦ Funções são encapsuladas como serviços. 47 Arquitetura OpenFaaS
  48. OpenWhisk • Lançado em 2016 • Desenvolvida pela IBM •

    Suporte Apache • Linguagens Suportadas ◦ JavaScript ◦ Go ◦ Python ◦ Java ◦ PHP ◦ Ruby ◦ Swift ◦ .NET 48
  49. OpenWhisk - Aquitetura 49 • Ações ◦ Funções Serverless •

    Gatilhos ◦ Dispara como resposta a um evento • Regras ◦ Conectam um Gatilho a uma Ação
  50. OpenWhisk - Aquitetura 50

  51. Detalhes do Sistema OpenWhisk • Namespace • Package 51

  52. Openlambda • Desenvolvido em 2016 • Norteada pela AWS Lambda

    • Linguagens Suportadas ◦ Java ◦ JavaScript ◦ Python 52
  53. Projetos de Pesquisa • Processamento de vídeo; ◦ Processamento de

    vídeos de forma escalável; ◦ Objetivo: baixo tempo de resposta; • Aprendizagem de máquina; ◦ Treino de modelos em clusters distribuídos; • Computação científica; ◦ Operações matemáticas como funções; 53
  54. • Computação nas bordas; ◦ FaaS resolve limitações de gerenciamento,

    volume de dados e custo; • Segurança; ◦ Meios de impedir ataques maliciosos em sistemas serverless; • Processamento em SmartNICs; ◦ SmartNICs no processamento de funções; ◦ Aumento da eficiência energética. 54 Projetos de Pesquisa
  55. Prática Neste módulo do curso demonstraremos como instalar e utilizar

    funções serverless utilizando a plataforma OpenFaaS. 55
  56. Instalação • No primeiro passo vamos instalar a plataforma no

    computador hospedeiro • Para instalar a plataforma primeiramente precisamos instalar os pacotes com se segue: $ sudo apt-get install git $ sudo apt-get install docker.io 56
  57. Instalação • Em seguida devemos clonar o repositório do OpenFaaS

    $ git clone https://github.com/openfaas/faas.git • Instalar a plataforma: $ sudo su $ cd faas $ make 57
  58. Instalação • Ainda é necessário construir e publicar. • Para

    construir use o script build via o comando: $ ./build.sh • Agora a plataforma está apta a ser publicada $ docker swarm init --advertise-addr [interface de rede] $ ./deploy_stack.sh 58
  59. Instalação • Serão criadas as credenciais de usuário e senha

    para acessar o serviço • Guarde estas credenciais, elas serão necessárias mais tarde • Acessar a plataforma em um navegador, no endereço 127.0.0.1 : 8080. 59
  60. Instalação da aplicação Cliente • Necessário para acesso do desenvolvedor

    a plataforma • Instalação via script. $ curl -sSL https://cli.openfaas.com | sudo sh • aplicação pronta para divulgar funções, o gateway por padrão é 127.0.0.1 : 8080. 60
  61. Instalação da aplicação Cliente • Realizar o login no gateway

    usando as credenciais obtidas no passo anterior: $ faas-cli login [--username USERNAME] [--password PASSWORD] • Caso deseje fazer o download de todos os templates oficiais basta executar: $ faas-cli template pull $ ls template/ 61
  62. Implementação de funções • Para começar a escrever as funções

    basta, digitar o seguinte comando: $ faas-cli new --lang [linguagem] [nome da função] • Para o exemplo inicial criaremos uma função python $ faas-cli new --lang python hello-minicurso 62
  63. Implementação de funções • Serão criados 3 arquivos • Um

    no diretório raiz e dois em uma pasta com o nome que foi dado para a função ◦ hello-minicurso/handler.py ◦ hello-minicurso/requirements.txt ◦ hello-minicurso.yml 63
  64. Implementação de funções • Primeiro edita-se o arquivo handler.py def

    handle(nome): print("Ola: " + nome) • O arquivo handler.py com é a função propriamente dita • Neste caso imprime na tela "Olá nome", sendo nome uma variável fornecida função como parâmetro. 64
  65. Implementação de funções • No arquivo hello-minicurso.yml são definidas as

    opções da função 65 provider: name: faas gateway: http://localhost:8080 functions: hello-minicurso: lang: python handler: ./hello-minicurso image: hello-minicurso
  66. Implementação de funções • No arquivo requirements.txt específica dependências da

    função. • Neste exemplo específico não será editado. • Construir a função com o comando: $ faas-cli build -f ./hello-minicurso.yml 66
  67. Implementação de funções • Com a imagem Serverless gerada pode-se

    publicar função: $ faas-cli deploy -f ./hello-minicurso.yml • Caso a função seja publicada sem nenhum erro, há um retorno da plataforma com código 200 e o endereço para invocar a função: 200 OK URL: http://localhost:8080/function/hello-minicurso • Função está publicada e pronta pra ser invocada. 67
  68. Invocar funções • Usuários podem invocar funções diretamente; • Requer

    o uso de softwares que atuam como clients; • Para isso, o software deve suportar o protocolo HTTP; • É possível enviar parâmetros de entrada; • Clients abordadas neste minicurso: ◦ cURL; ◦ FaaS CLI; ◦ UI Portal (nativo). 68
  69. cURL • Ferramenta de linha de comando; • Baseada na

    biblioteca libcurl; • Compatível com vários protocolos diferentes: ◦ HTTP; ◦ FTP; ◦ LDAP; etc. • Disponível para a maioria das versões Linux; • Instalação (Debian e derivados): $ apt-get install curl 69
  70. Invocando funções com cURL • Parâmetros: ◦ IP, porta, a

    função desejada e a lista de argumentos; • Exemplo: $ curl <ip>:<port>/function/<name> -d <arguments> $ curl localhost:8080/function/hello-minicurso \ -d "oi" 70
  71. FaaS CLI • Interface de linha de comando oficial do

    OpenFaaS; • Possui vários comandos de gerenciamento de funções; ◦ Lista completa: $ faas-cli help • Opção invoke: ◦ Permite invocar funções; ◦ Requer menos parâmetros do que o cURL; ◦ Os parâmetros são inseridos após a execução; • Exemplo: $ faas-cli invoke hello-minicurso 71
  72. UI Portal • Interface gráfica oficial do OpenFaaS; • Apresenta

    uma lista de funções ativas; • Possui uma interface de invocação interativa; • Pode ser acessado através do navegador (porta 8080): ◦ http://localhost:8080/ • Permite configurar o formato da saída: ◦ Texto simples; ◦ JSON; ◦ Download direto. 72
  73. UI Portal • Dados apresentados: ◦ Status da função; ◦

    Número de réplicas e de invocações; ◦ Imagem base, URL e processo principal. 73
  74. UI Portal • Dados apresentados: ◦ Status e corpo da

    resposta HTTP; ◦ Tempo de execução. 74
  75. Templates • Arquivos usados como modelo para novas funções; •

    Podem ser criados para qualquer linguagem; • Completamente customizáveis; • Estrutura geral: ◦ Dockerfile; ◦ index.ext; ◦ handler.ext; ◦ template.yml. 75
  76. Inserindo um template no OpenFaaS • Comandos iniciais: $ mkdir

    -p ~/functions && cd ~/functions $ faas-cli template pull $ cd template && ls $ mkdir c-language && cd c-language $ mkdir function/ && cd function/ $ touch header.h handler.h 76
  77. Inserindo um template no OpenFaaS • Conteúdo do arquivo header.h:

    #include <stdio.h> #include <stdlib.h> #include <string.h> int handler(char *entrada); 77
  78. • Conteúdo do arquivo header.c: #include "header.h" int handler(char *entrada)

    { printf("Oi! A mensagem é '%s'\n", entrada); return 0; } • Próximos comandos: $ cd .. $ touch index.c 78 Inserindo um template no OpenFaaS
  79. • Conteúdo do arquivo index.c: #include "header.h" #define TAM_MAX_DADOS 16

    int main() { char *dados; int tamanho; // Alocando a memória para o vetor de dados; dados = malloc(TAM_MAX_DADOS * sizeof(char)); 79 Inserindo um template no OpenFaaS
  80. • Conteúdo do arquivo index.c: // Armazenando dados da entrada

    padrão; fgets(dados, TAM_MAX_DADOS, stdin); tam = strlen(dados); // Removendo '\n' do final do vetor; if (dados[tam - 1] == '\n') dados[--tam] = '\0'; // Enviando dados recebidos para o handler; handler(dados); return 0; } 80 Inserindo um template no OpenFaaS
  81. • Próximos comandos: $ touch Dockerfile template.yml • Conteúdo do

    arquivo Dockerfile: FROM openfaas/classic-watchdog:0.18.0 as watchdog FROM alpine:latest RUN apk add build-base COPY --from=watchdog /fwatchdog /usr/bin/fwatchdog RUN chmod +x /usr/bin/fwatchdog 81 Inserindo um template no OpenFaaS
  82. • Conteúdo do arquivo Dockerfile: WORKDIR /app/ COPY function/header.h .

    COPY function/handler.c . COPY index.c . RUN gcc header.h handler.c \ index.c -static -o /exec \ && chmod +x /exec ENV fprocess="/exec" 82 Inserindo um template no OpenFaaS
  83. • Conteúdo do arquivo Dockerfile: HEALTHCHECK --interval=3s CMD [ -e

    /tmp/.lock ] || exit 1 CMD ["fwatchdog"] • Conteúdo do arquivo template.yml: language: c fprocess: /exec welcome_message: Parabéns! Você criou uma função serverless em C! 83 Inserindo um template no OpenFaaS
  84. eBPF • extended Berkeley Packet Filter • Máquina virtual RISC

    de 64 bits • Kernel do Linux • Processamento rápido de pacotes • Bytecode eBPF • Suporte C e P4 84
  85. eBPF • extended Berkeley Packet Filter • Máquina virtual RISC

    de 64 bits • Kernel do Linux • Processamento rápido de pacotes • Bytecode eBPF • Suporte C e P4 85
  86. Adicionando suporte uBPF no template C • uBPF • Alterar

    template C feito anteriormente • Instalar pacotes de dependências • Gerar a máquina virtual • Copiar o conteúdo da pasta c-language: $ cd ~/functions/template $ cp -r c-language c-ebpf && cd c-ebpf 86
  87. Adicionando suporte uBPF no template C • Alterar nosso Dockerfile

    • As linhas a diretica RUN abaixo deve ser adicionada loga após as diretivas FROM para instalar as dependências, 87 RUN apk add build-base \ clang \ git \ llvm
  88. Adicionando suporte uBPF no template C • Logo após a

    primeira definição de WORKDIR adicionar as linhas abaixo que fazem download do código do uBPF do repositório oficial e compilam a máquina virtual ubpf de teste, 88 RUN git clone https://github.com/iovisor/ubpf.git WORKDIR ubpf RUN make -C vm
  89. Adicionando suporte uBPF no template C • a linha abaixo

    deve ser adicionada apos o comando que copia o arquivo handle.c para compilar o código uBPF escrito pelo usuário no arquivo. • RUN clang -O2 -emit-llvm -c handler.c -o - | \ llc -march=bpf -filetype=obj -o handler.o 89
  90. Adicionando suporte uBPF no template C • Por fim adicionar

    a linha que executa o código gerado na maquina virtual. ENV fprocess="/home/app/ubpf/vm/test /home/app/ubpf/handler.o" 90
  91. Adicionando suporte uBPF no template C • O arquivo handle.c

    do template deve ser alterado como se segue #include "vm/inc/ubpf.h" int main() { } 91
  92. Exemplo: função uBPF • Primeiro instanciamos uma função baseada no

    template. $ faas-cli new --lang c-ebpf hello_ebpf $ cd hello_ebpf/function/ 92
  93. Exemplo: função uBPF • Adicionamos o código que queremos executar.

    Neste exemplo vamos apenas elevar uma constante ao quadrado, bastando para isso editar o arquivo handler.c 93 #include "vm/inc/ubpf.h" int main() { int a; a=2; return a*a; }
  94. Exemplo: função uBPF • Podemos gerar a imagem com o

    comando: $ faas-cli build -f ./hello-ebpf.yml • Com a imagem Serverless gerada, pode-se publicar função: $ faas-cli deploy -f ./hello-ebpf.yml 94
  95. Exemplo: função uBPF • Em seguida, invocar a função e

    receber o resultado esperado. $ curl http://127.0.0.1:8080/function/hello-ebpf $ 4 • Apesar de simples, o exemplo demonstra como, com essa ferramenta em mãos, se pode rapidamente gerar e disponibilizar funções ebpf. 95