instruction: Create a Dockerfile for workloads
output: ```dockerfile
  from a Pod
  
  Run Jobs
  
  Running Automated Tasks with a CronJob
  
  Coarse Parallel Processing Using a Work Queue
  
  Fine Parallel Processing Using a Work Queue
  
  Indexed Job for Parallel Processing with Static Work Assignment
  
  Job with Pod-to-Pod Communication
  
  Parallel Processing using Expansions
  
  Handling retriable and non-retriable pod failures with Pod failure policy
  
  Extend Kubernetes
  
  Configure the Aggregation Layer
  
  Use Custom Resources
  
  Extend the Kubernetes API with CustomResourceDefinitions
  
  Versions in CustomResourceDefinitions
  
  Set up an Extension API Server
  
  Configure Multiple Schedulers
  
  Use an HTTP Proxy to Access the Kubernetes API
  
  Use a SOCKS5 Proxy to Access the Kubernetes API
  
  Set up Konnectivity service
  
  Configurar um provedor de credenciais de imagem para o kubelet
  
  TLS
  
  Configure Certificate Rotation for the Kubelet
  
  Manage TLS Certificates in a Cluster
  
  Manual Rotation of CA Certificates
  
  Manage Cluster Daemons
  
  Perform a Rolling Update on a DaemonSet
  
  Perform a Rollback on a DaemonSet
  
  Running Pods on Only Some Nodes
  
  Networking
  
  Adding entries to Pod /etc/hosts with HostAliases
  
  Extend Service IP Ranges
  
  Validate IPv4/IPv6 dual-stack
  
  Limitar o consumo de armazenamento
  
  Extend kubectl with plugins
  
  Manage HugePages
  
  Personalizando o Serviço DNS
  
  Schedule GPUs
  
  Tutoriais
  
  Olá, Minikube!
  
  Aprenda as noções básicas do Kubernetes
  
  Crie um Cluster
  
  Usando Minikube para criar um cluster
  
  Implantar um aplicativo
  
  Usando kubectl para criar um Deployment
  
  Explore seu aplicativo
  
  Visualizando Pods e Nós
  
  Exponha publicamente seu aplicativo
  
  Utilizando um serviço para expor seu aplicativo
  
  Escale seu aplicativo
  
  Executando Múltiplas Instâncias da sua Aplicação
  
  Tutorial Interativo - Escalando seu aplicativo
  
  Update Your App
  
  Performing a Rolling Update
  
  Configuration
  
  Example: Configuring a Java Microservice
  
  Externalizing config using MicroProfile, ConfigMaps and Secrets
  
  Configuring Redis using a ConfigMap
  
  Security
  
  Apply Pod Security Standards at the Cluster Level
  
  Apply Pod Security Standards at the Namespace Level
  
  Restrict a Container's Access to Resources with AppArmor
  
  Restrict a Container's Syscalls with seccomp
  
  Stateless Applications
  
  Exposing an External IP Address to Access an Application in a Cluster
  
  Example: Deploying PHP Guestbook application with Redis
  
  Stateful Applications
  
  StatefulSet Basics
  
  Example: Deploying WordPress and MySQL with Persistent Volumes
  
  Example: Deploying Cassandra with a StatefulSet
  
  Running ZooKeeper, A Distributed System Coordinator
  
  Services
  
  Connecting Applications with Services
  
  Using Source IP
  
  Explore Termination Behavior for Pods And Their Endpoints
  
  Referência
  
  Glossário
  
  Autenticação
  
  API Overview
  
  Kubernetes API Concepts
  
  Server-Side Apply
  
  Client Libraries
  
  Common Expression Language in Kubernetes
  
  Kubernetes Deprecation Policy
  
  Deprecated API Migration Guide
  
  Kubernetes API health endpoints
  
  Autenticando com Tokens de Inicialização
  
  API Access Control
  
  Authenticating
  
  Authenticating with Bootstrap Tokens
  
  Certificates and Certificate Signing Requests
  
  Admission Controllers
  
  Dynamic Admission Control
  
  Managing Service Accounts
  
  Authorization Overview
  
  Using RBAC Authorization
  
  Using ABAC Authorization
  
  Using Node Authorization
  
  Mapping PodSecurityPolicies to Pod Security Standards
  
  Webhook Mode
  
  Kubelet authentication/authorization
  
  TLS bootstrapping
  
  Validating Admission Policy
  
  Well-Known Labels, Annotations and Taints
  
  Audit Annotations
  
  Ferramentas de Configuração
  
  Kubeadm
  
  kubeadm init
  
  kubeadm join
  
  kubeadm upgrade
  
  kubeadm config
  
  kubeadm reset
  
  kubeadm token
  
  kubeadm version
  
  kubeadm alpha
  
  kubeadm certs
  
  kubeadm init phase
  
  kubeadm join phase
  
  kubeadm kubeconfig
  
  kubeadm reset phase
  
  kubeadm upgrade phase
  
  Implementation details
  
  Kubernetes API
  
  Workload Resources
  
  Pod
  
  PodTemplate
  
  ReplicationController
  
  ReplicaSet
  
  Deployment
  
  StatefulSet
  
  ControllerRevision
  
  DaemonSet
  
  Job
  
  CronJob
  
  HorizontalPodAutoscaler
  
  HorizontalPodAutoscaler
  
  PriorityClass
  
  PodSchedulingContext v1alpha2
  
  ResourceClaim v1alpha2
  
  ResourceClaimTemplate v1alpha2
  
  ResourceClass v1alpha2
  
  Service Resources
  
  Service
  
  Endpoints
  
  EndpointSlice
  
  Ingress
  
  IngressClass
  
  Config and Storage Resources
  
  ConfigMap
  
  Secret
  
  Volume
  
  PersistentVolumeClaim
  
  PersistentVolume
  
  StorageClass
  
  VolumeAttachment
  
  CSIDriver
  
  CSINode
  
  CSIStorageCapacity
  
  Authentication Resources
  
  ServiceAccount
  
  TokenRequest
  
  TokenReview
  
  CertificateSigningRequest
  
  ClusterTrustBundle v1alpha1
  
  SelfSubjectReview
  
  Authorization Resources
  
  LocalSubjectAccessReview
  
  SelfSubjectAccessReview
  
  SelfSubjectRulesReview
  
  SubjectAccessReview
  
  ClusterRole
  
  ClusterRoleBinding
  
  Role
  
  RoleBinding
  
  Policy Resources
  
  LimitRange
  
  ResourceQuota
  
  NetworkPolicy
  
  PodDisruptionBudget
  
  IPAddress v1alpha1
  
  Extend Resources
  
  CustomResourceDefinition
  
  MutatingWebhookConfiguration
  
  ValidatingWebhookConfiguration
  
  ValidatingAdmissionPolicy v1beta1
  
  Cluster Resources
  
  Node
  
  Namespace
  
  Event
  
  APIService
  
  Lease
  
  RuntimeClass
  
  FlowSchema v1beta3
  
  PriorityLevelConfiguration v1beta3
  
  Binding
  
  ComponentStatus
  
  ClusterCIDR v1alpha1
  
  Common Definitions
  
  DeleteOptions
  
  LabelSelector
  
  ListMeta
  
  LocalObjectReference
  
  NodeSelectorRequirement
  
  ObjectFieldSelector
  
  ObjectMeta
  
  ObjectReference
  
  Patch
  
  Quantity
  
  ResourceFieldSelector
  
  Status
  
  TypedLocalObjectReference
  
  Other Resources
  
  ValidatingAdmissionPolicyBindingList v1beta1
  
  Common Parameters
  
  Portas e protocolos
  
  Instrumentation
  
  Service Level Indicator Metrics
  
  CRI Pod & Container Metrics
  
  Node metrics data
  
  Kubernetes Metrics Reference
  
  kubectl CLI
  
  Introduction To Kubectl
  
  kubectl Quick Reference
  
  kubectl reference
  
  kubectl
  
  kubectl annotate
  
  kubectl api-resources
  
  kubectl api-versions
  
  kubectl apply
  
  kubectl apply edit-last-applied
  
  kubectl apply set-last-applied
  
  kubectl apply view-last-applied
  
  kubectl attach
  
  kubectl auth
  
  kubectl auth can-i
  
  kubectl auth reconcile
  
  kubectl auth whoami
  
  kubectl autoscale
  
  kubectl certificate
  
  kubectl certificate approve
  
  kubectl certificate deny
  
  kubectl cluster-info
  
  kubectl cluster-info dump
  
  kubectl completion
  
  kubectl config
  
  kubectl config current-context
  
  kubectl config delete-cluster
  
  kubectl config delete-context
  
  kubectl config delete-user
  
  kubectl config get-clusters
  
  kubectl config get-contexts
  
  kubectl config get-users
  
  kubectl config rename-context
  
  kubectl config set
  
  kubectl config set-cluster
  
  kubectl config set-context
  
  kubectl config set-credentials
  
  kubectl config unset
  
  kubectl config use-context
  
  kubectl config view
  
  kubectl cordon
  
  kubectl cp
  
  kubectl create
  
  kubectl create clusterrole
  
  kubectl create clusterrolebinding
  
  kubectl create configmap
  
  kubectl create cronjob
  
  kubectl create deployment
  
  kubectl create ingress
  
  kubectl create job
  
  kubectl create namespace
  
  kubectl create poddisruptionbudget
  
  kubectl create priorityclass
  
  kubectl create quota
  
  kubectl create role
  
  kubectl create rolebinding
  
  kubectl create secret
  
  kubectl create secret docker-registry
  
  kubectl create secret generic
  
  kubectl create secret tls
  
  kubectl create service
  
  kubectl create service clusterip
  
  kubectl create service externalname
  
  kubectl create service loadbalancer
  
  kubectl create service nodeport
  
  kubectl create serviceaccount
  
  kubectl create token
  
  kubectl debug
  
  kubectl delete
  
  kubectl describe
  
  kubectl diff
  
  kubectl drain
  
  kubectl edit
  
  kubectl events
  
  kubectl exec
  
  kubectl explain
  
  kubectl expose
  
  kubectl get
  
  kubectl kustomize
  
  kubectl label
  
  kubectl logs
  
  kubectl options
  
  kubectl patch
  
  kubectl plugin
  
  kubectl plugin list
  
  kubectl port-forward
  
  kubectl proxy
  
  kubectl replace
  
  kubectl rollout
  
  kubectl rollout history
  
  kubectl rollout pause
  
  kubectl rollout restart
  
  kubectl rollout resume
  
  kubectl rollout status
  
  kubectl rollout undo
  
  kubectl run
  
  kubectl scale
  
  kubectl set
  
  kubectl set env
  
  kubectl set image
  
  kubectl set resources
  
  kubectl set selector
  
  kubectl set serviceaccount
  
  kubectl set subject
  
  kubectl taint
  
  kubectl top
  
  kubectl top node
  
  kubectl top pod
  
  kubectl uncordon
  
  kubectl version
  
  kubectl wait
  
  kubectl Commands
  
  kubectl
  
  JSONPath Support
  
  kubectl for Docker Users
  
  kubectl Usage Conventions
  
  kubectl Cheat Sheet
  
  Visão Geral de Autorização
  
  Problemas e Alertas de Segurança do Kubernetes
  
  Rastreador de Issue Kubernetes
  
  Kubernetes Security and Disclosure Information
  
  Feed Oficial de CVE
  
  Node Reference Information
  
  Kubelet Checkpoint API
  
  Articles on dockershim Removal and on Using CRI-compatible Runtimes
  
  Node Labels Populated By The Kubelet
  
  Kubelet Device Manager API Versions
  
  Node Status
  
  Utilizando Autorização ABAC
  
  Networking Reference
  
  Protocols for Services
  
  Ports and Protocols
  
  Virtual IPs and Service Proxies
  
  Component tools
  
  Feature Gates
  
  Feature Gates (removed)
  
  kubelet
  
  kube-apiserver
  
  kube-controller-manager
  
  kube-proxy
  
  kube-scheduler
  
  Debug cluster
  
  Flow control
  
  Configuration APIs
  
  Client Authentication (v1)
  
  Client Authentication (v1beta1)
  
  Event Rate Limit Configuration (v1alpha1)
  
  Image Policy API (v1alpha1)
  
  kube-apiserver Admission (v1)
  
  kube-apiserver Audit Configuration (v1)
  
  kube-apiserver Configuration (v1)
  
  kube-apiserver Configuration (v1alpha1)
  
  kube-apiserver Configuration (v1beta1)
  
  kube-apiserver Encryption Configuration (v1)
  
  kube-controller-manager Configuration (v1alpha1)
  
  kube-proxy Configuration (v1alpha1)
  
  kube-scheduler Configuration (v1)
  
  kubeadm Configuration (v1beta3)
  
  kubeadm Configuration (v1beta4)
  
  kubeconfig (v1)
  
  Kubelet Configuration (v1)
  
  Kubelet Configuration (v1alpha1)
  
  Kubelet Configuration (v1beta1)
  
  Kubelet CredentialProvider (v1)
  
  WebhookAdmission Configuration (v1)
  
  External APIs
  
  Kubernetes Custom Metrics (v1beta2)
  
  Kubernetes External Metrics (v1beta1)
  
  Kubernetes Metrics (v1beta1)
  
  Scheduling
  
  Scheduler Configuration
  
  Scheduling Policies
  
  Other Tools
  
  Ferramentas
  
  Contribuir
  
  Contribute to Kubernetes Documentation
  
  Suggesting content improvements
  
  Contributing new content
  
  Opening a pull request
  
  Documenting for a release
  
  Blogs and case studies
  
  Revisando mudanças
  
  Revisando pull requests
  
  For approvers and reviewers
  
  Localizing Kubernetes documentation
  
  Participating in SIG Docs
  
  Roles and responsibilities
  
  Issue Wranglers
  
  PR wranglers
  
  Updating Reference Documentation
  
  Quickstart
  
  Contributing to the Upstream Kubernetes Code
  
  Generating Reference Documentation for the Kubernetes API
  
  Generating Reference Documentation for kubectl Commands
  
  Generating Reference Documentation for Metrics
  
  Generating Reference Pages for Kubernetes Components and Tools
  
  Visão geral do estilo da documentação
  
  Guia de conteúdo
  
  Guia de estilo
  
  Diagram guide
  
  Writing a new topic
  
  Page content types
  
  Content organization
  
  Custom Hugo Shortcodes
  
  Advanced contributing
  
  Visualizando Analytics do Site
  
   Docs smoke test page (EN)
  
  Resultados da pesquisa
  
  Documentação
  
  Conceitos
  
  Visão Geral
  
   Você está vendo a documentação do Kubernetes versão: v1.29
  
   Kubernetes v1.29 a documentação não é mais mantida ativamente. A versão que você está visualizando no momento é uma cópia estática. Para obter a documentação atualizada, consulte
   última versão.
  
  Visão Geral
  Kubernetes é um plataforma de código aberto, portável e extensiva para o gerenciamento de cargas de trabalho e serviços distribuídos em contêineres, que facilita tanto a configuração declarativa quanto a automação. Ele possui um ecossistema grande, e de rápido crescimento. Serviços, suporte, e ferramentas para Kubernetes estão amplamente disponíveis.
  
  Essa página é uma visão geral do Kubernetes.
  
  Kubernetes é um plataforma de código aberto, portável e extensiva para o gerenciamento de cargas de trabalho e serviços distribuídos em contêineres, que facilita tanto a configuração declarativa quanto a automação. Ele possui um ecossistema grande, e de rápido crescimento. Serviços, suporte, e ferramentas para Kubernetes estão amplamente disponíveis.
  O Google tornou Kubernetes um projeto de código-aberto em 2014. O Kubernetes combina mais de 15 anos de experiência do Google executando cargas de trabalho produtivas em escala, com as melhores idéias e práticas da comunidade.
  O nome Kubernetes tem origem no Grego, significando timoneiro ou piloto. K8s é a abreviação derivada pela troca das oito letras "ubernete" por "8", se tornado K"8"s.
  Voltando no tempo
  Vamos dar uma olhada no porque o Kubernetes é tão útil, voltando no tempo.
  
  Era da implantação tradicional: No início, as organizações executavam aplicações em servidores físicos. Não havia como definir limites de recursos para aplicações em um mesmo servidor físico, e isso causava problemas de alocação de recursos. Por exemplo, se várias aplicações fossem executadas em um mesmo servidor físico, poderia haver situações em que uma aplicação ocupasse a maior parte dos recursos e, como resultado, o desempenho das outras aplicações seria inferior. Uma solução para isso seria executar cada aplicação em um servidor físico diferente. Mas isso não escalava, pois os recursos eram subutilizados, e se tornava custoso para as organizações manter muitos servidores físicos.
  Era da implantação virtualizada: Como solução, a virtualização foi introduzida. Esse modelo permite que você execute várias máquinas virtuais (VMs) em uma única CPU de um servidor físico. A virtualização permite que as aplicações sejam isoladas entre as VMs, e ainda fornece um nível de segurança, pois as informações de uma aplicação não podem ser acessadas livremente por outras aplicações.
  A virtualização permite melhor utilização de recursos em um servidor físico, e permite melhor escalabilidade porque uma aplicação pode ser adicionada ou atualizada facilmente, reduz os custos de hardware e muito mais. Com a virtualização, você pode apresentar um conjunto de recursos físicos como um cluster de máquinas virtuais descartáveis.
  Cada VM é uma máquina completa que executa todos os componentes, incluindo seu próprio sistema operacional, além do hardware virtualizado.
  Era da implantação em contêineres: Contêineres são semelhantes às VMs, mas têm propriedades de isolamento flexibilizados para compartilhar o sistema operacional (SO) entre as aplicações. Portanto, os contêineres são considerados leves. Semelhante a uma VM, um contêiner tem seu próprio sistema de arquivos, compartilhamento de CPU, memória, espaço de processo e muito mais. Como eles estão separados da infraestrutura subjacente, eles são portáveis entre nuvens e distribuições de sistema operacional.
  Contêineres se tornaram populares porque eles fornecem benefícios extra, tais como:
  
  Criação e implantação ágil de aplicações: aumento da facilidade e eficiência na criação de imagem de contêiner comparado ao uso de imagem de VM.
  Desenvolvimento, integração e implantação contínuos: fornece capacidade de criação e de implantação de imagens de contêiner de forma confiável e frequente, com a funcionalidade de efetuar reversões rápidas e eficientes (devido à imutabilidade da imagem).
  Separação de interesses entre Desenvolvimento e Operações: crie imagens de contêineres de aplicações no momento de construção/liberação em vez de no momento de implantação, desacoplando as aplicações da infraestrutura.
  A capacidade de observação (Observabilidade) não apenas apresenta informações e métricas no nível do sistema operacional, mas também a integridade da aplicação e outros sinais.
  Consistência ambiental entre desenvolvimento, teste e produção: funciona da mesma forma em um laptop e na nuvem.
  Portabilidade de distribuição de nuvem e sistema operacional: executa no Ubuntu, RHEL, CoreOS, localmente, nas principais nuvens públicas e em qualquer outro lugar.
  Gerenciamento centrado em aplicações: eleva o nível de abstração da execução em um sistema operacional em hardware virtualizado à execução de uma aplicação em um sistema operacional usando recursos lógicos.
  Microserviços fracamente acoplados, distribuídos, elásticos e livres: as aplicações são divididas em partes menores e independentes e podem ser implantados e gerenciados dinamicamente - não uma pilha monolítica em execução em uma grande máquina de propósito único.
  Isolamento de recursos: desempenho previsível de aplicações.
  Utilização de recursos: alta eficiência e densidade.
  
  Por que você precisa do Kubernetes e o que ele pode fazer
  Os contêineres são uma boa maneira de agrupar e executar suas aplicações. Em um ambiente de produção, você precisa gerenciar os contêineres que executam as aplicações e garantir que não haja tempo de inatividade. Por exemplo, se um contêiner cair, outro contêiner precisa ser iniciado. Não seria mais fácil se esse comportamento fosse controlado por um sistema?
  É assim que o Kubernetes vem ao resgate! O Kubernetes oferece uma estrutura para executar sistemas distribuídos de forma resiliente. Ele cuida do escalonamento e da recuperação à falha de sua aplicação, fornece padrões de implantação e muito mais. Por exemplo, o Kubernetes pode gerenciar facilmente uma implantação no método canário para seu sistema.
  O Kubernetes oferece a você:
  
  Descoberta de serviço e balanceamento de carga
  O Kubernetes pode expor um contêiner usando o nome DNS ou seu próprio endereço IP. Se o tráfego para um contêiner for alto, o Kubernetes pode balancear a carga e distribuir o tráfego de rede para que a implantação seja estável.
  Orquestração de armazenamento
  O Kubernetes permite que você monte automaticamente um sistema de armazenamento de sua escolha, como armazenamentos locais, provedores de nuvem pública e muito mais.
  Lançamentos e reversões automatizadas
  Você pode descrever o estado desejado para seus contêineres implantados usando o Kubernetes, e ele pode alterar o estado real para o estado desejado em um ritmo controlado. Por exemplo, você pode automatizar o Kubernetes para criar novos contêineres para sua implantação, remover os contêineres existentes e adotar todos os seus recursos para o novo contêiner.
  Empacotamento binário automático
  Você fornece ao Kubernetes um cluster de nós que pode ser usado para executar tarefas nos contêineres. Você informa ao Kubernetes de quanta CPU e memória (RAM) cada contêiner precisa. O Kubernetes pode encaixar contêineres em seus nós para fazer o melhor uso de seus recursos.
  Autocorreção
  O Kubernetes reinicia os contêineres que falham, substitui os contêineres, elimina os contêineres que não respondem à verificação de integridade definida pelo usuário e não os anuncia aos clientes até que estejam prontos para servir.
  Gerenciamento de configuração e de segredos
  O Kubernetes permite armazenar e gerenciar informações confidenciais, como senhas, tokens OAuth e chaves SSH. Você pode implantar e atualizar segredos e configuração de aplicações sem reconstruir suas imagens de contêiner e sem expor segredos em sua pilha de configuração.
  
  O que o Kubernetes não é
  O Kubernetes não é um sistema PaaS (plataforma como serviço) tradicional e completo. Como o Kubernetes opera no nível do contêiner, e não no nível do hardware, ele fornece alguns recursos geralmente aplicáveis comuns às ofertas de PaaS, como implantação, escalonamento, balanceamento de carga, e permite que os usuários integrem suas soluções de logging, monitoramento e alerta. No entanto, o Kubernetes não é monolítico, e essas soluções padrão são opcionais e conectáveis. O Kubernetes fornece os blocos de construção para a construção de plataformas de desenvolvimento, mas preserva a escolha e flexibilidade do usuário onde é importante.
  Kubernetes:
  
  Não limita os tipos de aplicações suportadas. O Kubernetes visa oferecer suporte a uma variedade extremamente diversa de cargas de trabalho, incluindo cargas de trabalho sem estado, com estado e de processamento de dados. Se uma aplicação puder ser executada em um contêiner, ele deve ser executado perfeitamente no Kubernetes.
  Não implanta código-fonte e não constrói sua aplicação. Os fluxos de trabalho de integração contínua, entrega e implantação (CI/CD) são determinados pelas culturas e preferências da organização, bem como pelos requisitos técnicos.
  Não fornece serviços em nível de aplicação, tais como middleware (por exemplo, barramentos de mensagem), estruturas de processamento de dados (por exemplo, Spark), bancos de dados (por exemplo, MySQL), caches, nem sistemas de armazenamento em cluster (por exemplo, Ceph), como serviços integrados. Esses componentes podem ser executados no Kubernetes e/ou podem ser acessados por aplicações executadas no Kubernetes por meio de mecanismos portáteis, como o Open Service Broker.
  Não dita soluções de logging, monitoramento ou alerta. Ele fornece algumas integrações como prova de conceito e mecanismos para coletar e exportar métricas.
  Não fornece nem exige um sistema/idioma de configuração (por exemplo, Jsonnet). Ele fornece uma API declarativa que pode ser direcionada por formas arbitrárias de especificações declarativas.
  Não fornece nem adota sistemas abrangentes de configuração de máquinas, manutenção, gerenciamento ou autocorreção.
  Adicionalmente, o Kubernetes não é um mero sistema de orquestração. Na verdade, ele elimina a necessidade de orquestração. A definição técnica de orquestração é a execução de um fluxo de trabalho definido: primeiro faça A, depois B e depois C. Em contraste, o Kubernetes compreende um conjunto de processos de controle independentes e combináveis que conduzem continuamente o estado atual em direção ao estado desejado fornecido. Não importa como você vai de A para C. O controle centralizado também não é necessário. Isso resulta em um sistema que é mais fácil de usar e mais poderoso, robusto, resiliente e extensível.
  
  Próximos passos
  
  Dê uma olhada em Componentes do Kubernetes.
  Pronto para Iniciar?
  
  Comentários
  Esta página foi útil?
  Sim
  Não
  
   Obrigado pelo feedback. Se você tiver uma pergunta específica sobre como utilizar o Kubernetes, faça em
  
   Stack Overflow.
   Abra um bug no repositório do GitHub se você deseja
  
   relatar um problema
   ou
  
   sugerir uma melhoria.
  
   Última modificação July 08, 2023 at 7:01 PM PST: [pt-br] Update docs/concepts/overview/_index.md (#41070) (9493bb5ab1)
  
   Editar essa página
   Criar uma subpágina
   Abra um bug
   Imprimir toda essa seção
  
  Voltando no tempo
  Por que você precisa do Kubernetes e o que ele pode fazer
  O que o Kubernetes não é
  Próximos passos
  
  Documentação
  Blog
  Parceiros
  Comunidade
  Casos de estudo
  
  © 2025 Os autores do Kubernetes | Documentação Distribuída sob CC BY 4.0
  
  ICP license: 京ICP备17074266号-3
  ```