Visão Geral

O Curso gRPC Google Remote Procedure Call é um treinamento prático que introduz os participantes ao gRPC, um framework moderno de chamadas remotas de procedimentos (RPC) baseado em HTTP/2 e Protocol Buffers. Ele ensina como criar serviços eficientes, escaláveis e interoperáveis para comunicação entre sistemas distribuídos, como microsserviços. Os participantes aprenderão a definir contratos de serviço com Protobuf, implementar servidores e clientes em diferentes linguagens, e explorar recursos como streaming bidirecional. o Curso gRPC Google Remote Procedure Call combina teoria, demonstrações e exercícios práticos para capacitar os alunos a utilizar o gRPC em aplicações reais.

Objetivo

Após realizar este gRPC Google Remote Procedure Call, você será capaz de:

• Definir contratos de serviço usando Protocol Buffers (Protobuf) para o gRPC.
• Implementar servidores e clientes gRPC em uma linguagem de programação (ex.: Python ou Go).
• Configurar comunicação unária e streaming (server, client e bidirecional) com gRPC.
• Integrar o gRPC em aplicações distribuídas com segurança (TLS) e monitoramento básico.
• Aplicar boas práticas para design, desempenho e manutenção de serviços gRPC.

Publico Alvo

• Desenvolvedores de software que trabalham com sistemas distribuídos ou microsserviços.
• Engenheiros de backend interessados em comunicação eficiente entre serviços.
• Arquitetos de software buscando alternativas modernas a REST ou SOAP.
• Profissionais de DevOps que gerenciam infraestrutura de APIs e serviços.
• Estudantes ou entusiastas de tecnologia explorando frameworks de RPC.

Pre-Requisitos

• Conhecimento básico de programação em pelo menos uma linguagem (ex.: Python, Go, Java).
• Familiaridade com conceitos de sistemas distribuídos (ex.: cliente-servidor, APIs).
• Noções introdutórias de redes (ex.: HTTP, TCP/IP) são recomendadas.
• Experiência com linha de comando (ex.: terminal Linux ou Windows) é útil.

Materiais

Conteúdo Programatico

Dia 1 – Módulo 1: Introdução ao gRPC

• Tópicos:
  1. O que é gRPC: definição, história e comparação com REST e SOAP.
  2. Benefícios: desempenho (HTTP/2), interoperabilidade e tipagem forte.
  3. Componentes principais: Protocol Buffers, HTTP/2 e modelos de chamada (unária, streaming).
  4. Casos de uso: microsserviços, IoT, comunicação em tempo real.
  5. Instalação: configuração do ambiente e ferramentas (Protoc, bibliotecas gRPC).
• Atividade Prática: Instalar o Protoc e bibliotecas gRPC em uma linguagem escolhida (ex.: Python).

Dia 1 – Módulo 2: Definindo Serviços com Protocol Buffers

• Tópicos:
  1. Introdução ao Protocol Buffers (Protobuf): sintaxe, mensagens e serviços.
  2. Criação de arquivos .proto: definição de mensagens e métodos RPC.
  3. Compilação do Protobuf: geração de código para cliente e servidor.
  4. Estrutura básica: unária (solicitação-resposta) vs. streaming.
  5. Validação: teste de arquivos .proto compilados.
• Atividade Prática: Criar e compilar um arquivo .proto simples com um serviço de saudação (ex.: "Hello World").

Dia 1 – Módulo 3: Implementação de Servidor e Cliente gRPC

• Tópicos:
  1. Configuração de um servidor gRPC: implementação de métodos definidos no .proto.
  2. Criação de um cliente gRPC: chamada aos métodos do servidor.
  3. Comunicação unária: envio e recebimento de mensagens simples.
  4. Teste básico: execução do servidor e cliente localmente.
• Atividade Prática: Implementar um servidor e cliente gRPC para o serviço "Hello World" em Python ou Go.

Dia 2 – Módulo 4: Streaming e Recursos Avançados

• Tópicos:
  1. Tipos de streaming: server-side, client-side e bidirecional.
  2. Implementação de streaming: exemplos práticos (ex.: chat ou envio de dados contínuos).
  3. Gerenciamento de erros: códigos de status gRPC e tratamento de exceções.
  4. Segurança: configuração de TLS para comunicação criptografada.
  5. Depuração: uso de logs e ferramentas (ex.: grpcurl) para análise.
• Atividade Prática: Criar um serviço de streaming bidirecional (ex.: chat simples) com TLS habilitado.

Dia 2 – Módulo 5: Boas Práticas e Integração

• Tópicos:
  1. Design de serviços: boas práticas para .proto (versionamento, compatibilidade).
  2. Otimização: ajustes de desempenho (ex.: pooling de conexões, compressão).
  3. Monitoramento: integração com ferramentas como Prometheus ou logs customizados.
  4. Integração em sistemas: uso com microsserviços ou aplicações existentes.
  5. Próximos passos: exploração de gRPC-Gateway e suporte a múltiplas linguagens.
• Atividade Prática: Otimizar o serviço de chat com logs e testar com múltiplos clientes.