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.

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