DevOps nativo de nuvem com Kubernetes

Como construir, implantar e escalar aplicações modernas na nuvem

DevOps nativo de nuvem com Kubernetes Esgotado
× DevOps nativo de nuvem com Kubernetes

DevOps nativo de nuvem com Kubernetes

Compartilhar

Autores: John Arundel
Justin Domingus

ISBN impresso: 978-85-7522-778-7
ISBN ebook: 978-85-7522-779-4
Ano: 2019
Páginas: 384
Preço: R$ 93,00

2 opiniões | Opine sobre este livro

Descrição do livro

O Kubernetes é o sistema operacional do mundo nativo de nuvem e oferece uma plataforma confiável e escalável para executar cargas de trabalho em contêineres. Neste livro aprazível e pragmático, os especialistas em nuvem John Arundel e Justin Domingus mostram o que o Kubernetes é capaz de fazer – e o que você pode fazer com ele.

Você conhecerá tudo sobre o ecossistema do Kubernetes e usará soluções testadas em experiências reais para resolver seus problemas do dia a dia. Além disso, construirá, passo a passo, um exemplo de uma aplicação nativa de nuvem com sua infraestrutura de suporte, além de um ambiente de desenvolvimento e um pipeline de implantação contínua que poderão ser usados em suas próprias aplicações.

  • Entenda os contêineres e o Kubernetes desde os princípios básicos; nenhuma experiência é necessária.

  • Execute os próprios clusters ou escolha um serviço gerenciado de Kubernetes da Amazon, do Google ou de outros fornecedores.

  • Use o Kubernetes para gerenciar o uso de recursos e o ciclo de vida dos contêineres.

  • Otimize clusters quanto a custos, desempenho, resiliência, capacidade e escalabilidade.

  • Conheça as melhores ferramentas para desenvolvimento, testes e implantação de suas aplicações.

  • • Aplique as práticas mais recentes do mercado para segurança, observabilidade e monitoração.

  • Adote princípios de DevOps para ajudar suas equipes de desenvolvimento a se tornarem mais enxutas, rápidas e eficientes.

Ver menos ▲

Sumário

  • Apresentação
  • Prefácio
  • Capítulo 1 • Revolução na nuvem
    • Criação da nuvem
      • Comprando tempo
      • Infraestrutura como serviço
    • Surgimento do DevOps
      • Ninguém compreende o DevOps
      • Vantagem para os negócios
      • Infraestrutura como código
      • Aprendendo juntos
    • Surgimento dos contêineres
      • Estado da arte
      • Pensando dentro da caixa
      • Colocando software em contêineres
      • Aplicações plug and play
    • Conduzindo a orquestra de contêineres
    • Kubernetes
      • Do Borg ao Kubernetes
      • O que faz o Kubernetes ser tão valioso?
      • O Kubernetes vai desaparecer?
      • Kubernetes não faz tudo
    • Nativo de nuvem
    • Futuro das operações
      • DevOps distribuído
      • Algumas tarefas permanecerão centralizadas
      • Engenharia de produtividade de desenvolvedores
      • Você é o futuro
    • Resumo
  • Capítulo 2 • Primeiros passos com o Kubernetes
    • Executando seu primeiro contêiner
      • Instalando o Docker Desktop
      • O que é o Docker?
      • Executando uma imagem de contêiner
    • Aplicação demo
      • Observando o código-fonte
      • Introdução ao Go
      • Como a aplicação demo funciona
    • Construindo um contêiner
      • Compreendendo os Dockerfiles
      • Imagens mínimas de contêiner
      • Executando o comando docker image build
      • Dando nomes às suas imagens
      • Encaminhamento de portas
    • Registros de contêineres
      • Autenticando-se no registro
      • Nomeando e enviando sua imagem
      • Executando sua imagem
    • Olá, Kubernetes
      • Executando a aplicação demo
      • Se o contêiner não iniciar
    • Minikube
    • Resumo
  • Capítulo 3 • Obtendo o Kubernetes
    • Arquitetura de um cluster
      • Plano de controle
      • Componentes de um nó
      • Alta disponibilidade
    • Custos de auto-hospedagem do Kubernetes
      • É mais trabalhoso do que você imagina
      • Não se trata apenas da configuração inicial
      • Ferramentas não fazem todo o trabalho por você
      • Kubernetes é difícil
      • Overhead de administração
      • Comece com serviços gerenciados
    • Serviços gerenciados de Kubernetes
      • Google Kubernetes Engine (GKE)
      • Escalabilidade automática de clusters
      • Amazon Elastic Container Service for Kubernetes (EKS)
      • Azure Kubernetes Service (AKS)
      • OpenShift
      • IBM Cloud Kubernetes Service
      • Heptio Kubernetes Subscription (HKS)
    • Soluções turnkey para Kubernetes
      • Stackpoint
      • Containership Kubernetes Engine (CKE)
    • Instaladores de Kubernetes
      • kops
      • Kubespray
      • TK8
      • Kubernetes The Hard Way
      • kubeadm
      • Tarmak
      • Rancher Kubernetes Engine (RKE)
      • Módulo Kubernetes do Puppet
      • Kubeformation
    • Comprar ou construir: nossas recomendações
      • Execute menos software
      • Use Kubernetes gerenciado se puder
      • O que dizer de ficar preso a um fornecedor?
      • Use ferramentas padrões para Kubernetes auto-hospedado, se precisar
      • Quando suas opções forem limitadas
      • Bare metal e on premises
      • Serviço de contêineres sem cluster
      • Amazon Fargate
      • Azure Container Instances (ACI)
    • Resumo
  • Capítulo 4 • Trabalhando com objetos Kubernetes
    • Deployments
      • Supervisão e escalonamento
      • Reiniciando contêineres
      • Consultando Deployments
    • Pods
    • ReplicaSets
    • Mantendo o estado desejado
    • Escalonador do Kubernetes
    • Manifestos de recursos no formato YAML
      • Recursos são dados
      • Manifestos de Deployments
      • Usando o comando kubectl apply
      • Recursos Service
      • Consultando o cluster com kubectl
      • Levando os recursos ao próximo nível
    • Helm: um gerenciador de pacotes para Kubernetes
      • Instalando o Helm
      • Instalando um Helm chart
      • Charts, repositórios e releases
      • Listando releases do Helm
    • Resumo
  • Capítulo 5 • Gerenciando recursos
    • Compreendendo os recursos
      • Unidades para recursos
      • Solicitação de recursos
      • Limite de recursos
      • Mantenha seus contêineres pequenos
    • Gerenciando o ciclo de vida do contêiner
      • Liveness probes
      • Atraso inicial e frequência do probe
      • Outros tipos de probes
      • Probes gRPC
      • Readiness probes
      • Readiness probes baseados em arquivo
      • minReadySeconds
      • Pod Disruption Budgets
    • Usando namespaces
      • Trabalhando com namespaces
      • Quais namespaces devo usar?
      • Endereços de serviços
      • Quota de recursos
      • Solicitações e limites default para recursos
    • Otimizando os custos do cluster
      • Otimizando implantações
      • Otimizando Pods
      • Vertical Pod Autoscaler
      • Otimizando nós
      • Otimizando a armazenagem
      • Limpeza de recursos não usados
      • Verificando a capacidade sobressalente
      • Usando instâncias reservadas
      • Usando instâncias preemptivas (Spot)
      • Mantendo suas cargas de trabalho balanceadas
    • Resumo
  • Capítulo 6 • Operação de clusters
    • Como dimensionar e escalar clusters
      • Planejamento da capacidade
      • Nós e instâncias
      • Escalando o cluster
    • Verificação de conformidade
      • Certificação CNCF
      • Testes de conformidade com o Sonobuoy
    • Validação e auditoria
      • K8Guard
      • Copper
      • kube-bench
      • Logging de auditoria do Kubernetes
    • Testes de caos
      • Somente a produção é a produção
      • chaoskube
      • kube-monkey
      • PowerfulSeal
    • Resumo
  • Capítulo 7 • Ferramentas eficazes do Kubernetes
    • Dominando o kubectl
      • Aliases de shell
      • Usando flags abreviadas
      • Abreviando tipos de recursos
      • Preenchimento automático de comandos kubectl
      • Obtendo ajuda
      • Obtendo ajuda sobre os recursos do Kubernetes
      • Exibindo uma saída mais detalhada
      • Trabalhando com dados JSON e jq
      • Observando objetos
      • Descrevendo objetos
    • Trabalhando com recursos
      • Comandos imperativos do kubectl
      • Quando não usar comandos imperativos
      • Gerando manifestos de recursos
      • Exportando recursos
      • Verificando a diferença entre recursos
    • Trabalhando com contêineres
      • Visualizando os logs de um contêiner
      • Conectando-se com um contêiner
      • Observando recursos do Kubernetes com o kubespy
      • Encaminhando uma porta de contêiner
      • Executando comandos em contêineres
      • Executando contêineres para resolução de problemas
      • Usando comandos do BusyBox
      • Adicionando o BusyBox aos seus contêineres
      • Instalando programas em um contêiner
      • Depuração ao vivo com o kubesquash
    • Contextos e namespaces
      • kubectx e kubens
      • kube-ps1
    • Shells e ferramentas para Kubernetes
      • kube-shell
      • Click
      • kubed-sh
      • Stern
    • Construindo suas próprias ferramentas para Kubernetes
    • Resumo
  • Capítulo 8 • Executando contêineres
    • Contêineres e Pods
      • O que é um contêiner?
      • O que há em um contêiner?
      • O que há em um Pod?
    • Manifestos de contêineres
      • Identificadores de imagem
      • Tag latest
      • Digests de contêineres
      • Tags de imagens de base
      • Portas
      • Solicitações e limites de recursos
      • Política para baixar imagens
      • Variáveis de ambiente
    • Segurança nos contêineres
      • Executando contêineres com um usuário diferente de root
      • Bloqueando contêineres com root
      • Configurando um sistema de arquivos somente para leitura
      • Desativando a escalação de privilégios
      • Capacidades
      • Contexto de segurança dos Pods
      • Políticas de segurança dos Pods
      • Contas de serviço dos Pods
    • Volumes
      • Volumes emptyDir
      • Volumes persistentes
    • Políticas de reinicialização
    • Secrets para download de imagens
    • Resumo
  • Capítulo 9 • Gerenciando Pods
    • Rótulos
      • O que são rótulos?
      • Seletores
      • Seletores mais sofisticados
      • Outros usos para os rótulos
      • Rótulos e anotações
    • Afinidades de nós
      • Afinidades hard
      • Afinidades soft
    • Afinidades é antiafinidades de Pods
      • Mantendo Pods juntos
      • Mantendo Pods separados
      • Antiafinidades soft
      • Quando usar afinidades de Pods
    • Taints e tolerâncias
    • Controladores de Pods
      • DaemonSets
      • StatefulSets
      • Jobs
      • Cronjobs
      • Horizontal Pod Autoscalers
      • PodPresets
      • Operadores e Custom Resource Definitions (CRDs)
    • Recursos Ingress
      • Regras do Ingress
      • Terminação de TLS com Ingress
      • Controladores de Ingress
    • Istio
    • Envoy
    • Resumo
  • Capítulo 10 • Configuração e dados sigilosos
    • ConfigMaps
      • Criando ConfigMaps
      • Configurando variáveis de ambiente a partir de ConfigMaps
      • Configurando o ambiente completo a partir de um ConfigMap
      • Usando variáveis de ambiente em argumentos de comando
      • Criando arquivos de configuração a partir de ConfigMaps
      • Atualizando Pods quando há uma mudança de configuração
    • Secrets do Kubernetes
      • Usando Secrets como variáveis de ambiente
      • Escrevendo Secrets em arquivos
      • Lendo Secrets
      • Acesso aos Secrets
      • Criptografia at rest
      • Mantendo os Secrets
    • Estratégias para gerenciamento de Secrets
      • Criptografar dados sigilosos no sistema de controle de versões
      • Armazenar dados sigilosos remotamente
      • Usar uma ferramenta dedicada de gerenciamento de dados sigilosos
      • Recomendações
    • Criptografando dados sigilosos com o Sops
      • Introdução ao Sops
      • Criptografando um arquivo com o Sops
      • Usando um backend KMS
    • Resumo
  • Capítulo 11 • Segurança e backups
    • Controle de acesso e permissões
      • Administrando o acesso por cluster
      • Introdução ao Role-Based Access Control (RBAC)
      • Compreendendo os perfis
      • Vinculando perfis a usuários
      • Quais perfis são necessários?
      • Proteja o acesso ao cluster-admin
      • Aplicações e implantações
      • Resolução de problemas do RBAC
    • Scanning de segurança
      • Clair
      • Aqua
      • Anchore Engine
    • Backups
      • Preciso fazer backup do Kubernetes?
      • Backup do etcd
      • Backup do estado dos recursos
      • Backup do estado do cluster
      • Desastres grandes e pequenos
      • Velero
    • Monitorando o status do cluster
      • kubectl
      • Utilização de CPU e de memória
      • Console do provedor de nuvem
      • Dashboard do Kubernetes
      • Weave Scope
      • kube-ops-view
      • node-problem-detector
    • Leitura complementar
    • Resumo
  • Capítulo 12 • Implantação de aplicações Kubernetes
    • Construindo manifestos com o Helm
      • O que há em um Helm chart?
      • Templates do Helm
      • Interpolando variáveis
      • Inserindo aspas em valores nos templates
      • Especificando dependências
    • Implantação de Helm charts
      • Configurando variáveis
      • Especificando valores em uma release do Helm
      • Atualizando uma aplicação com o Helm
      • Fazendo rollback para versões anteriores
      • Criando um repositório de Helm charts
      • Gerenciando dados sigilosos do Helm chart com o Sops
    • Gerenciando vários charts com o Helmfile
      • O que há em um Helmfile?
      • Metadados do chart
      • Aplicando o Helmfile
    • Ferramentas sofisticadas para gerenciamento de manifestos
      • ksonnet
      • Kapitan
      • kustomize
      • kompose
      • Ansible
      • kubeval
    • Resumo
  • Capítulo 13 • Fluxo de trabalho do desenvolvimento
    • Ferramentas de desenvolvimento
      • Skaffold
      • Draft
      • Telepresence
      • Knative
    • Estratégias de implantação
      • Atualizações contínuas
      • Recreate
      • maxSurge e maxUnavailable
      • Implantações azul/verde
      • Implantações arco-íris
      • Implantações canário
    • Cuidando de migrações com o Helm
      • Hooks do Helm
      • Tratando hooks com falha
      • Outros hooks
      • Encadeamento de hooks
    • Resumo
  • Capítulo 14 • Implantação contínua no Kubernetes
    • O que é implantação contínua?
    • Qual ferramenta de CD devo usar?
      • Jenkins
      • Drone
      • Google Cloud Build
      • Concourse
      • Spinnaker
      • GitLab CI
      • Codefresh
      • Azure Pipelines
    • Componentes do CD
      • Docker Hub
      • Gitkube
      • Flux
      • Keel
    • Um pipeline de CD com o Cloud Build
      • Configurando o Google Cloud e o GKE
      • Criando um fork no repositório da aplicação demo
      • Introdução ao Cloud Build
      • Construindo o contêiner de teste
      • Executando os testes
      • Construindo o contêiner da aplicação
      • Validando os manifestos do Kubernetes
      • Publicando a imagem
      • Tags SHA do Git
      • Criando o primeiro trigger da construção
      • Testando o trigger
      • Implantação a partir de um pipeline de CD
      • Criando um trigger para implantação
      • Otimizando seu pipeline de construção
      • Adaptando o pipeline do exemplo
    • Resumo
  • Capítulo 15 • Observabilidade e monitoração
    • O que é observabilidade?
      • O que é monitoração?
      • Monitoração caixa-preta
      • O que significa “up”?
      • Logging
      • Introdução às métricas
      • Tracing
      • Observabilidade
    • Pipeline de observabilidade
    • Monitoração no Kubernetes
      • Verificações caixa-preta externas
      • Verificações de sanidade internas
    • Resumo
  • Capítulo 16 • Métricas no Kubernetes
    • Afinal de contas, o que são métricas?
      • Dados de séries temporais
      • Contadores e indicadores
      • O que as métricas podem nos dizer?
    • Escolhendo boas métricas
      • Serviços: o padrão RED
      • Recursos: o padrão USE
      • Métricas de negócio
      • Métricas do Kubernetes
    • Analisando métricas
      • O que há de errado com uma simples média?
      • Médias, medianas e valores discrepantes
      • Descobrindo os percentis
      • Aplicando percentis aos dados de métricas
      • Geralmente, queremos saber o pior
      • Além dos percentis
    • Gerando gráficos de métricas em painéis de controle
      • Use um layout padrão para todos os serviços
      • Construa um irradiador de informações com painéis de controle mestres
      • Coloque informações no painel de controle sobre itens que falham
    • Alertas com base em métricas
      • O que há de errado com os alertas?
      • Estar de plantão não deve ser o inferno
      • Alertas urgentes, importantes e passíveis de ação
    • Ferramentas e serviços relacionados a métricas
      • Prometheus
      • Google Stackdriver
      • AWS Cloudwatch
      • Azure Monitor
      • Datadog
      • New Relic
    • Resumo
  • Posfácio
    • Para onde ir em seguida
    • Bem-vindo a bordo
  • Sobre os autores
  • Colofão
Ver sumário completo ▼

Sobre os autores

John Arundel

John Arundel é consultor e autor, com mais de 30 anos de experiência no mercado de informática. Trabalha com empresas do mundo todo, prestando consultoria sobre Kubernetes, nuvem e infraestrutura.… Ver perfil completo ▶

Justin Domingus

Justin Domingus é engenheiro de DevOps na CareZone.com e especialista em Kubernetes e computação em nuvem.… Ver perfil completo ▶

Opinião dos leitores

Andre L F

Recomendo este livro para quem está iniciando os estudos sobre DevOps.

Aecio d S P

Livro muito bem traduzido. Os autores têm alto domínio sobre ambientes de nuvem e implantação de sistemas com conteineres e Kubernetes e no livro apresentam uma compilação das melhores práticas e experiência adquirida com o tempo não só deles, mas de centenas de outros profissionais com quem eles interagiram. Recomendo este livro para pessoas que têm conhecimento em Linux e Docker, iniciantes ou não prática da cultura DevOps e Kubernetes.

Ver todas ▼