As 44 principais perguntas e respostas da entrevista sobre Kubernetes em 2025

Perguntas básicas da entrevista sobre Kubernetes

Vamos começar agora com as perguntas básicas da entrevista sobre o Kubernetes. Essas perguntas abrangem o conhecimento básico necessário para você entender e trabalhar com o Kubernetes. 

O que é um pod no Kubernetes?

Um Pod é a menorunidadeimplementável no Kubernetes. Ele representa um ou mais contêineres em execução em um ambiente compartilhado. Os contêineres dentro de um pod compartilham recursos de rede e armazenamento.

Aqui está um arquivo YAML simples de definição de pod:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Qual é a finalidade do kubectl?

O Kubectl é a principal ferramenta de CLI para gerenciar os recursos do Kubernetes e interagir com o cluster. Aqui estão alguns comandos comuns do kubectl com os quais você deve estar familiarizado:

kubectl get pods 				 # list all Pods
kubectl get services 			 # list all Services
kubectl logs <pod-name> 	  	 # view logs of a Pod
kubectl exec -it <pod-name> – /bin/sh # open a shell inside a Pod

O que é uma implantação no Kubernetes?

Uma implantação no Kubernetes é uma abstração de nível superior que gerencia o ciclo de vida dos pods. Ele garante que o número desejado de réplicas esteja em funcionamento e oferece recursos como atualizações contínuas, reversões e autocorreção. 

Veja a seguir a aparência de um arquivo YAML de definição de implantação simples: 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

O que é um serviço Kubernetes e por que ele é necessário?

Um serviço no Kubernetes expõe um grupo de pods e permite a comunicação entre eles e com eles. 

Como os pods são efêmeros, seus IPs podem mudar, o que significa que o aplicativo que se comunica com os pods também deve alterar o endereço IP. Os serviços, portanto, fornecem um ponto de extremidade de rede estável com um endereço IP fixo.

Uma definição simples de YAML de serviço:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

O serviço acima encaminha o tráfego para os pods que têm o rótulo app: my-app.

Quais tipos de serviço estão disponíveis nos Serviços do Kubernetes?

O Kubernetes oferece quatro tipos principais de serviços, cada um servindo a uma finalidade de rede diferente:

• ClusterIP (padrão): Permite a comunicação interna dos pods. Acessível somente de dentro do cluster.
• NodePort: Isso expõe o serviço em uma porta estática de cada nó, tornando-o acessível de fora do cluster.
• LoadBalancer: Usa o balanceador de carga externo de um provedor de nuvem. O serviço pode ser acessado por meio de um IP público.
• ExternalName: Mapeia um serviço Kubernetes para um nome de host externo. 

Qual é a função dos ConfigMaps e dos segredos no Kubernetes?

O ConfigMaps armazena dados de configuração não confidenciais, enquanto o secrets armazena dados confidenciais, como chaves e senhas de API.

O uso de segredos permite que você evite colocar informações secretas no código do aplicativo. Em contrapartida, os ConfigMaps permitirão que você torne seus aplicativos mais configuráveis, pois esses valores podem ser facilmente editados e você não precisa mantê-los no código do aplicativo.

Exemplo de definição de ConfigMap YAML:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  database_url: "postgres://db.example.com"

Exemplo de definição secreta de YAML (com dados codificados em base64):

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  password: cGFzc3dvcmQ=  # "password" encoded in Base64

O que são Namespaces no Kubernetes?

Um Namespace é um cluster virtual em um cluster do Kubernetes. Ele ajuda a organizar as cargas de trabalho em ambientes multilocatários, isolando os recursos em um cluster.

Abaixo, você encontra um pequeno trecho de código que mostra como criar um Namespace usando o kubectl e como criar e buscar Pods nesse Namespace:

# create a namespace called “dev”
kubectl create namespace dev

# create a Pod in that namespace
kubectl run nginx --image=nginx --namespace=dev

# get Pods in that namespace
kubectl get pods --namespace=dev

O que são rótulos e seletores no Kubernetes?

Os rótulos são pares de chave/valor anexados a objetos (por exemplo, pods). Eles ajudam a organizar os objetos do Kubernetes. Os seletores filtram recursos com base em rótulos. 

Aqui está um exemplo de POD que tem os rótulos environment: production e app: nginx:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  labels:
    environment: production
    app: nginx
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Agora você pode usar o seletor de rótulo a seguir para buscar todos os pods que têm o rótulo environment: pod atribuído:

kubectl get pods -l environment=production

O que são Volumes Persistentes (PVs) e Reivindicações de Volume Persistente (PVCs)?

Os PVs (Persistent Volumes, volumes persistentes) fornecem armazenamento que persiste além dos ciclos de vida do Pod. O PV é uma parte do armazenamento no cluster que foi provisionada por um administrador de cluster ou provisionada dinamicamente usando Classes de armazenamento.

Uma Reivindicação de Volume Persistente (PVC) é uma solicitação de armazenamento feita por um usuário. 

Aqui está um exemplo de definição de PV e PVC YAML: 

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  hostPath:
    path: "/mnt/data"

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Perguntas da entrevista sobre Kubernetes intermediário

Agora que você praticou o básico, podemos passar para as perguntas de nível intermediário. Compreender conceitos como rede, segurança, gerenciamento de recursos e solução de problemas é essencial nesse nível.

O que é a rede Kubernetes e como ela funciona?

A rede do Kubernetes permite a comunicação entre pods, serviços e clientes externos. Ele segue uma estrutura de rede plana, o que significa que, por padrão, todos os pods podem se comunicar uns com os outros.  

Os principais conceitos de rede no Kubernetes incluem:

• Comunicação de pod para pod: Cada pod recebe um IP exclusivo atribuído e pode se comunicar dentro do cluster. 
• Comunicação de serviço para pod: Os serviços fornecem um ponto de extremidade de rede estável para um grupo de pods, pois os pods são efêmeros. Cada pod recebe um novo IP atribuído sempre que é criado.
• Controladores de ingresso: Gerenciar o tráfego HTTP/HTTPS externo.
• Políticas de rede: Defina regras para restringir ou permitir a comunicação entre os pods.

O que é controle de acesso baseado em função (RBAC) no Kubernetes?

O RBAC é um mecanismo de segurança que restringe usuários e serviços com base em suas permissões. Ele consiste em:

• Funções e ClusterRoles: Defina as ações permitidas nos recursos.
• RoleBindings e ClusterRoleBindings: Atribua funções a usuários ou contas de serviço.

O YAML a seguir mostra um exemplo de função que permite somente acesso de leitura aos pods:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
rules:
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "watch", "list"]

Essa função pod-reader agora pode ser vinculada a um usuário usando RoleBinding:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: pod-reader-binding
subjects:
  - kind: User
    name: dummy
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Como funciona o escalonamento automático do Kubernetes?

O Kubernetes oferece três tipos de escalonamento automático para otimizar o uso de recursos:

1. Autoscaler de pod horizontal (HPA): Ajusta o número de pods com base no uso da CPU, no uso da memória ou em métricas personalizadas.
2. Autoscaler de pod vertical (VPA): Ajusta as solicitações de CPU e memória para Pods individuais.
3. Autoscaler de cluster: Ajusta o número de nós de trabalho no cluster com base nas necessidades de recursos.

Você pode criar um HPA usando o kubectl:

kubectl autoscale deployment nginx --cpu-percent=50 --min=1 --max=10

O comando acima cria um HPA para uma implantação com o nome nginx e tenta manter a utilização média da CPU em todos os pods em 50%, com um número mínimo de réplicas em 1 e um número máximo de réplicas em 10.

Como você depura os pods do Kubernetes?

Quando os pods falham, o Kubernetes oferece várias maneiras de depurá-los:

• Use kubectl logs para verificar se há erros nos registros do contêiner.
• Use o site kubectl describe pod para inspecionar eventos e alterações recentes de estado.
• Use kubectl exec para abrir um shell interativo e investigar de dentro do contêiner.
• Use kubectl get pods --field-selector=status.phase=Failed para listar todos os pods com falha.

# get logs of a specific Pod
kubectl get logs <pod-name>

# describe the Pod and check events
kubectl describe pod <pod-name>

# open an interactive shell inside the Pod
kubectl exec -it <pod-name> – /bin/sh

# check all failing pods
kubectl get pods --field-selector=status.phase=Failed

Esses comandos ajudam a identificar configurações incorretas, restrições de recursos ou erros de aplicativos.

Como você realiza atualizações e reversões contínuas no Kubernetes?

As implantações do Kubernetes suportam atualizações contínuas para evitar tempo de inatividade. Você pode realizar uma atualização contínua editando um Deployment ou definindo explicitamente sua imagem para uma nova versão usando:

kubectl set image deployment/my-deployment nginx=nginx:1.21

Em seguida, você pode verificar o status da implantação:

kubectl rollout status deployment my-deployment

Se quiser reverter para a versão anterior, você pode executar:

kubectl rollout undo deployment my-deployment

O que é um Ingress no Kubernetes e como ele funciona?

Um Ingress é um objeto de API que gerencia o acesso HTTP/HTTPS externo aos serviços dentro de um cluster do Kubernetes.  Ele permite o roteamento de solicitações com base no nome do host e nos caminhos, atuando como um proxy reverso para vários aplicativos.

Exemplo de definição YAML do Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
    - host: my-app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: my-service
                port:
                  number: 80

Como o Kubernetes lida com limites e solicitações de recursos?

O Kubernetes permite que você defina solicitações e limites de recursos para Pods para garantir uma alocação justa e evitar o uso excessivo dos recursos do cluster.

• As solicitações são a quantidade mínima de CPU e memória que um POD precisa. Eles são atribuídos permanentemente a um pod. 
• Os limites são o máximo que um POD pode usar. Eles não são atribuídos ao pod, mas se ele precisar de mais recursos, poderá crescer até que o limite seja atingido.

Exemplo de definição de pod YAML que define solicitações e limites de recursos:

apiVersion: v1
kind: Pod
metadata:
  name: resource-limited-pod
spec:
  containers:
    - name: my-container
      image: nginx
      resources:
        requests:
          memory: "256Mi"
          cpu: "250m"
        limits:
          memory: "512Mi"
          cpu: "500m"

O que acontecerá se um recurso do POD precisar crescer além dos limites atribuídos?

Se o consumo de memória de um Pod exceder o limite de memória atribuído, o Kubernetes imediatamente encerra o contêiner com um erro de falta de memória (OOM). O contêiner será reiniciado se uma política de reinicialização for definida.

Ao contrário da memória, se um pod exceder o limite de CPU atribuído, ele nãoserá eliminado. Em vez disso, o Kubernetes limita o uso da CPU, fazendo com que o aplicativo fique mais lento.

O que são contêineres init e quando você deve usá-los?

Os contêineres de inicialização são contêineres especiais que são executados antes do início dos contêineres primários. Eles ajudam a preparar o ambiente verificando dependências, carregando arquivos de configuração ou configurando dados.

Um exemplo poderia ser um contêiner de inicialização que espera que um banco de dados esteja em funcionamento:

apiVersion: v1
kind: Pod
metadata:
  name: app-with-init
spec:
  initContainers:
    - name: wait-for-db
      image: busybox
      command: ['sh', '-c', 'until nc -z db-service 5432; do sleep 2; done']
  containers:
    - name: my-app
      image: my-app-image

Como o Kubernetes lida com interrupções de pods e alta disponibilidade?

O Kubernetes garante alta disponibilidade por meio de PDBs (Pod Disruption Budgets), regras de antiafinidade e mecanismos de autocorreção. Veja como esses mecanismos funcionam:

• Orçamento de interrupção de pod (PDB): Garante que um número mínimo de pods permaneça disponível durante interrupções voluntárias (por exemplo, atualizações de cluster em que os nós precisam ser reduzidos).
• Afinidade e antiafinidade de pod: Controles para os quais os pods podem ser programados juntos ou separadamente.
• Seletores de nós e Taints/Tolerâncias: Controle como as cargas de trabalho são distribuídas entre os nós.

Aqui está um exemplo de definição de PDB YAML que garante que pelo menos dois pods permaneçam em execução durante as interrupções:

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: my-app-pdb
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: my-app

Perguntas avançadas da entrevista sobre Kubernetes

Esta seção aborda perguntas avançadas de entrevistas sobre o Kubernetes, com foco em aplicativos com estado, gerenciamento de vários clusters, segurança, otimização de desempenho e solução de problemas. Se você estiver se candidatando a um cargo sênior, não deixe de conferir essas informações.

O que são StatefulSets e como eles diferem de Deployments?

Um StatefulSet é usado para aplicativos com estado que exigem identidades de rede estáveis, armazenamento persistente e implantação ordenada. Ao contrário das implantações, os StatefulSets garantem que você tenha um bom desempenho:

• Os pods têm identidades de rede estáveis e exclusivas, onde os pods são nomeados como pod-0, pod-1 etc.
• Os pods são criados, atualizados e excluídos em ordem.
• Cada pod mantém o armazenamento persistente durante as reinicializações. O armazenamento persistente é definido como parte da definição YAML do StatefulSet.

O que é uma malha de serviço e por que ela é usada no Kubernetes?

Uma malha de serviço gerencia serviço a serviço comunicaçãofornecendo:

• Gerenciamento de tráfego (balanceamento de carga, implementações canárias).
• Segurança (criptografia mTLS entre serviços).
• Observabilidade (rastreamento, métricas, registro)

Todos esses recursos estão incluídos na camada de infraestrutura, portanto, não são necessárias alterações no código. 

As soluções populares de malha de serviço do Kubernetes incluem: Istio, Linkerd e Consul.

Como você pode proteger um cluster do Kubernetes?

Siga o modelo de segurança 4C para proteger um cluster do Kubernetes:

1. Segurança do provedor de nuvem: Use funções de IAM e regras de firewall.
2. Segurança do cluster: Ative o RBAC, os registros de auditoria e a segurança do servidor de API.
3. Segurança de contêineres: Digitalize imagens e use usuários não root.
4. Segurança do código: Implemente o gerenciamento de segredos e use políticas de rede.

O que são tintas e tolerâncias no Kubernetes?

Os Taints e Tolerations controlam onde os Pods são executados:

• Manchas: Marque os nós para rejeitar os pods.
• Tolerâncias: Permitir que os Pods ignorem determinados Taints.

Aqui está um exemplo de como você pode manchar um nó apenas para aceitar cargas de trabalho específicas:

kubectl taint nodes node1 key1=value1:NoSchedule

Isso significa que nenhum pod pode ser agendado em node1 até que você tenha a tolerância necessária.

Uma tolerância é adicionada na seção PodSpec como a seguinte:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    env: test
spec:
  containers:
  - name: nginx
    image: nginx
    imagePullPolicy: IfNotPresent
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: “value1”
    effect: "NoSchedule"

O POD poderia ser agendado em node1.

O que são contêineres sidecar do Kubernetes e como eles são usados?

Um contêiner sidecar é executado juntamente com o contêiner do aplicativo principal dentro do mesmo Pod. É comumente usado para:

• Registro e monitoramento (por exemplo, coleta de registros com o Fluentd).
• Proxies de segurança (por exemplo, executando o proxy Envoy do Istio para service mesh).
• Gerenciamento de configuração (por exemplo, sincronização de configurações de aplicativos).

Exemplo de contêiner sidecar para processamento de registros:

apiVersion: v1
kind: Pod
metadata:
  name: app-with-sidecar
spec:
  containers:
    - name: main-app
      image: my-app
      volumeMounts:
        - mountPath: /var/log
          name: shared-logs
    - name: log-collector
      image: fluentd
      volumeMounts:
        - mountPath: /var/log
          name: shared-logs
  volumes:
    - name: shared-logs
      emptyDir: {}

O contêiner sidecar executa o Fluentd, que coleta logs do contêiner principal por meio de um volume compartilhado.

Cite três causas típicas de erros de POD e como eles podem ser corrigidos.

Os pods podem ficar presos em Pendente, CrashLoopBackOffou ImagePullBackOff estados:

• Pod preso em Pendente: Verifique a disponibilidade do nó e os limites de recursos. Você pode verificar os eventos do Pod para obter mais informações.
• CrashLoopBackOff: Investigue os registros de aplicativos e verifique as configurações incorretas.
• ImagePullBackOff: Verifique se o nome da imagem e as credenciais de extração estão corretos. Novamente, investigue os eventos do POD para obter mais informações.

Você pode verificar os eventos do pod usando o comando describe:

kubectl describe pod <pod-name>

O que é um webhook de admissão mutante do Kubernetes e como ele funciona?

Um webhook de admissão mutante permite a modificação em tempo real dos objetos do Kubernetes antes de serem aplicados ao cluster e persistidos. Ele executa um controlador de admissão dinâmico no Kubernetes que intercepta solicitações de API antes que os objetos sejam persistidos no etcd. Ele pode modificar a carga útil da solicitação injetando, alterando ou removendo campos antes de permitir que a solicitação prossiga.

Eles são comumente usados para:

• Injetando sidecars.
• Definir valores padrão para pods, implantações ou outros recursos.
• Aplicação de práticas recomendadas (por exemplo, atribuição automática de limites de recursos).
• Adicionar configurações de segurança (por exemplo, exigir etiquetas para rastreamento de auditoria).

Como você implementa implantações com tempo de inatividade zero no Kubernetes?

As implementações com tempo de inatividade zero garantem que as atualizações não interrompam o tráfego ao vivo. O Kubernetes consegue isso usando:

• Atualizações contínuas (padrão, substituindo gradualmente os Pods antigos por novos).
• Implantações canárias (testes com um subconjunto de usuários).
• Implantações azul-verde (alternando entre ambientes de produção e de teste).

As sondas de prontidão ajudam o Kubernetes a evitar que o tráfego seja enviado para pods que não estão prontos.

O que são Definições de Recursos Personalizados (CRDs) do Kubernetes e quando você deve usá-las?

Uma definição de recurso personalizado (CRD) estende as APIs do Kubernetes, permitindo que os usuários definam e gerenciem recursos personalizados. Eles são usados para casos de uso específicos em que a API do Kubernetes ainda deve ser usada para gerenciar esses recursos, como:

• Gerenciar aplicativos personalizados (por exemplo, modelos de aprendizado de máquina).
• Habilitando os operadores do Kubernetes para aplicativos de autocorreção.

Exemplo de definição CRD YAML:

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: shirts.stable.example.com
spec:
  group: stable.example.com
  scope: Namespaced
  names:
    plural: shirts
    singular: shirt
    kind: Shirt
  versions:
  - name: v1
    served: true
    storage: true
    schema:
      openAPIV3Schema:
        type: object
        properties:
          spec:
            type: object
            properties:
              color:
                type: string
              size:
                type: string
    selectableFields:
    - jsonPath: .spec.color
    - jsonPath: .spec.size
    additionalPrinterColumns:
    - jsonPath: .spec.color
      name: Color
      type: string
    - jsonPath: .spec.size
      name: Size
      type: string

Agora você pode, por exemplo, recuperar o objeto shirt usando o kubectl:

kubectl get shirts

Descubra como aproveitar o Docker e o Kubernetes para fluxos de trabalho de aprendizado de máquina neste tutorial prático sobre conteinerização.

O que são operadores de Kubernetes e como eles funcionam?

Um operador do Kubernetes amplia a funcionalidade do Kubernetes automatizando a implantação, o dimensionamento e o gerenciamento de aplicativos complexos. Ele é criado usando CRDs e controladores personalizados para lidar com a lógica específica do aplicativo.

Os operadores trabalham definindo recursos personalizados no Kubernetes e observando as alterações no cluster para automatizar tarefas específicas. 

Esses são os principais componentes de um operador:

• Definição de recursos personalizados (CRD): Define um novo recurso da API do Kubernetes.
• Controlador personalizado: Observa o CRD e aplica a lógica de automação com base no estado desejado.
• Loop de reconciliação: Garante continuamente que o estado do aplicativo corresponda ao estado esperado.

Perguntas da entrevista sobre Kubernetes para administradores

Os administradores do Kubernetes mantêm, protegem e otimizam os clusters para cargas de trabalho de produção. Esta seção aborda as perguntas da entrevista do Kubernetes com foco no gerenciamento de clusters.

Como você faz backup e restaura um cluster etcd no Kubernetes?

O Etcd é o armazenamento de valores-chave que mantém todo o estado do cluster. Backups regulares são essenciais para evitar a perda de dados.

Você pode criar um backup usando o comando abaixo:

ETCDCTL_API=3 etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=<trusted-ca-file> --cert=<cert-file> --key=<key-file> \
  snapshot save <backup-file-location>

Se agora você quiser restaurar a partir de um backup, poderá executar:

etcdutl --data-dir <data-dir-location> snapshot restore snapshot.db

Como você pode atualizar com segurança um cluster do Kubernetes?

A atualização de um cluster do Kubernetes é um processo de várias etapas que requer um tempo mínimo de inatividade e mantém a estabilidade do cluster. Os administradores devem seguir uma abordagem estruturada para evitar problemas durante o upgrade:

1. Faça a drenagem e o backup do etcd antes da atualização para garantir que você possa restaurá-lo caso a atualização falhe.
2. Atualize o nó do plano de controle.
3. Atualize o kubelet e o kubectl nos nós do plano de controle.
4. Atualize os nós de trabalho um a um. Antes de fazer o upgrade, cada nó de trabalho deve ser drenado para evitar a interrupção da carga de trabalho.
5. Atualize os complementos do cluster (por exemplo, controladores Ingress, ferramentas de monitoramento, etc.).

Como você monitora um cluster do Kubernetes?

Os administradores do Kubernetes devem monitorar a CPU, a memória, o disco, a rede e a integridade do aplicativo. As ferramentas a seguir são recomendadas para essas tarefas:

• Prometheus + Grafana: Colete e visualize as métricas de cluster. Crie alertas em tempo real para ser notificado caso haja problemas.
• Loki + Fluentd: Colete e analise os registros.
• Painel de controle do Kubernetes: Monitoramento de cluster baseado em UI.
• Jaeger/OpenTelemetry: Rastreamento distribuído.

Como você protege um cluster do Kubernetes?

A segurança é um aspecto fundamental, e todo administrador deve seguir as práticas recomendadas para proteger um cluster do Kubernetes:

• Ativar o RBAC: Restringir o acesso do usuário usando funções e RoleBindings.
• Admissão de segurança do pod: Use controladores de admissão para aplicar os padrões de segurança do POD.
• Aplicar NetworkPolicies: Restringir a comunicação entre pods, pois, por padrão, todos os pods podem se comunicar uns com os outros.
• Faça a rotação regular dos tokens e certificados de API.
• Use o gerenciamento de segredos: Use ferramentas como Vault, AWS Secrets Manager, etc. 

Saiba como o Kubernetes é implementado na nuvem com este guia sobre orquestração de contêineres usando o AWS Elastic Kubernetes Service (EKS).

Como você configura o registro em log do Kubernetes?

O registro centralizado é necessário para depuração e auditoria. Duas opções diferentes de pilha de registro:

• Loki + Fluentd + Grafana (Leve e rápido).
• Pilha ELK (Elastic, Logstash, Kibana) (escalável e de nível empresarial).

Como você implementa a alta disponibilidade no Kubernetes?

A alta disponibilidade é essencial para evitar o tempo de inatividade dos aplicativos em execução no cluster do Kubernetes. Você pode garantir a alta disponibilidade:

• Uso de vários nós do plano de controle. Vários servidores de API evitam o tempo de inatividade se um deles falhar.
• Ativação do autoscaler do cluster. Isso adiciona/remove nós automaticamente com base na demanda.

Como você implementa a multitenancy do cluster Kubernetes?

A multilocação é muito importante se você estiver configurando o Kubernetes para sua empresa. Ele permite que várias equipes ou aplicativos compartilhem um cluster Kubernetes de forma segura, sem interferir uns nos outros.

Há dois tipos de multilocação:

1. Multitenancy suave: Usa Namespaces, RBAC e NetworkPolicies para isolar no nível do namespace.
2. Multitenancy rígido: Usa clusters virtuais ou planos de controle separados para isolar um cluster físico (por exemplo, KCP).

Como você criptografa os segredos do Kubernetes no etcd?

O Etcd armazena o estado completo do cluster, o que significa que as informações críticas são armazenadas nele. 

Por padrão, o Kubernetesarmazena segredos não criptografados no etcd, tornando-os vulneráveis a comprometimentos. Portanto, pode ser crucial habilitar a criptografia secreta no REST para que os segredos sejam armazenados e criptografados.

Como primeira etapa, você precisa criar um arquivo de configuração de criptografia e armazenar uma chave de criptografia/descriptografia nesse arquivo:

apiVersion: apiserver.config.k8s.io/v1
kind: EncryptionConfiguration
resources:
  - resources:
      - secrets
    providers:
      - aescbc:
          keys:
            - name: key1
              secret: <BASE64_ENCODED_SECRET>
      - identity: {}

A configuração acima especifica que o Kubernetes usará o provedor aescbc para criptografar recursos secretos, com um fallback para identity para dados não criptografados.

Em seguida, você precisa adaptar o arquivo de configuração kube-apiserver, normalmente encontrado em /etc/kubernetes/manifests/kube-apiserver.yaml em um nó do plano de controle, e incluir o sinalizador -- encryption-provider-config apontando para o arquivo de configuração de criptografia que você criou:

command:
  - kube-apiserver
  ...
  - --encryption-provider-config=/path/to/encryption-config.yaml

Salve as alterações e reinicie o site kube-apiserver para aplicar a nova configuração.

Como você gerencia as cotas de recursos do Kubernetes em ambientes multilocatários?

As cotas de recursos impedem que um único locatário (namespace) consuma excessivamente os recursos do cluster, impedindo que outros locatários trabalhem.

Você pode definir ResourceQuotas para namespaces para dar uma determinada quantidade de recursos a esse namespace específico. Os usuários desse namespace podem, então, criar recursos que consumam a quantidade de recursos definida na ResourceQuota desse namespace.

Exemplo de definição YAML de ResourceQuota:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: namespace-quota
  namespace: team-a
spec:
  hard:
    requests.cpu: "4"
    requests.memory: "8Gi"
    limits.cpu: "8"
    limits.memory: "16Gi"
    pods: "20"

Você pode verificar o ResourceQuota de um namespace usando:

kubectl describe resourcequota namespace-quota -n team-a

O que é CoreDNS? Como você o configura e usa?

O CoreDNS é o provedor de DNS padrão para clusters do Kubernetes. Ele fornece descoberta de serviços e permite que os pods se comuniquem usando nomes DNS internos em vez de endereços IP.

Recursos do CoreDNS:

• Lida com a resolução interna de DNS (my-service.default.svc.cluster.local).
• Oferece suporte à configuração de DNS personalizado.
• Equilibra a carga das consultas de DNS em vários pods.
• Permite o armazenamento em cache para melhorar o desempenho.

Você pode configurar o CoreDNS usando o ConfigMap armazenado no namespace kube-system. Você pode visualizar as configurações atuais usando:

kubectl get configmap coredns -n kube-system -o yaml

Basta atualizar esse ConfigMap e aplicar as alterações para adaptar a configuração do CoreDNS.

Perguntas da entrevista sobre Kubernetes baseadas em cenários e na resolução de problemas

Os engenheiros enfrentam regularmente desafios complexos de escalabilidade, rede, segurança, desempenho e solução de problemas em ambientes Kubernetes do mundo real, e os entrevistadores sabem disso. Esta seção apresenta perguntas de entrevista baseadas em cenários que testam sua capacidade de resolver problemas práticos do Kubernetes.

Depuração de um aplicativo Kubernetes lento

"Sua equipe relata que um aplicativo em execução no Kubernetes ficou lento e os usuários estão enfrentando altos tempos de resposta. Como você resolve esse problema?"

Você pode abordar o problema usando as seguintes etapas:

1. Verifique a utilização dos recursos do Pod. Aumente os recursos caso eles estejam em seus limites.

kubectl top pods --sort-by=cpu
kubectl top pods --sort-by=memory

2. Descreva o Pod lento para obter mais informações. Procure por limitação de recursos, contagens de reinicialização ou falhas na sonda de vivacidade.

kubectl describe pod <pod-name>

3. Verifique se há erros nos registros do contêiner. Procure por tempos limite, erros ou falhas de conexão.

kubectl logs <pod-name>

4. Teste a latência da rede, pois ela pode tornar os aplicativos mais lentos.

kubectl exec -it <pod-name> -- ping my-database
kubectl exec -it <pod-name> -- curl http://my-service

5. Verificar a integridade do nó do Kubernetes e verificar se há exaustão de recursos nos nós.

kubectl get nodes
kubectl describe node <node-name>

Um servidor da Web Nginx está em execução, mas o URL exposto não consegue se conectar

"Você implantou um servidor da Web Nginx no Kubernetes, e o Pod está funcionando bem, mas o aplicativo nãoestá acessível por meio do URL exposto. O que você pode fazer a respeito?"

Etapas para abordar o problema acima:

1. Verifique se o pod Nginx está em execução e íntegro.

kubectl get pods -o wide
kubectl describe pod nginx-web

2. Verifique o mapeamento de serviços e portas. Verifique se a porta correta está exposta e se corresponde à porta do contêiner do pod. Verifique se o serviço encontra os pods corretos.

kubectl describe service nginx-service

3. Verifique as políticas de rede. Se uma política de rede bloquear o tráfego de entrada, o serviço não poderá ser acessado.

kubectl get networkpolicies
kubectl describe networkpolicy <policy-name>

4. Verifique a configuração do DNS de entrada e externo.

kubectl describe ingress nginx-ingress

A implantação do Kubernetes falha após uma atualização

"Você implantou uma nova versão do seu aplicativo, mas ele não consegue iniciar, causando tempo de inatividade para seus usuários. Como você pode resolver o problema?"

Abordagem para lidar com o problema:

1. Reverter para a versão de trabalho anterior.

kubectl rollout undo deployment my-app

2. Verifique o histórico de implementação e identifique o que foi alterado na nova versão.

kubectl rollout history deployment my-app

3. Verifique se há erros nos registros do novo pod.

kubectl logs -l app=my-app

4. Verifique as sondas de prontidão e vivacidade.

5. Verifique os problemas de extração de imagens. Às vezes, a nova imagem está errada ou não está disponível.

O aplicativo não pode se conectar a um banco de dados externo

"Um microsserviço em execução no Kubernetes não consegue se conectar a um banco de dados externo, que está hospedado fora do cluster. Como você pode resolver o problema?"

Etapas para abordar o problema:

1. Verifique a conectividade externa de dentro de um pod. Verifique se o banco de dados pode ser acessado pela rede do Kubernetes.

kubectl exec -it <pod-name> -- curl http://my-database.example.com:5432

2. Verifique a resolução de DNS dentro do pod. Se falhar, o CoreDNS pode estar configurado incorretamente.

kubectl exec -it <pod-name> -- nslookup my-database.example.com

3. Verifique se existem políticas de rede que bloqueiam o acesso externo, pois elas podem impedir o tráfego de saída.

kubectl get networkpolicies
kubectl describe networkpolicy <policy-name>

Os recursos do cluster estão esgotados, fazendo com que os novos pods permaneçam em um estado pendente

"Os novos pods permanecem no estado Pendente. Analisando mais detalhadamente os pods, vemos que a mensagem "0/3 nodes are available: insufficient CPU and memory" (0/3 nós estão disponíveis: CPU e memória insuficientes). Como você faz para depurar e resolver o problema?"

Etapas para abordar o problema:

1. Verifique a disponibilidade dos recursos do cluster. Procure um alto uso de CPU/memória que impeça o agendamento.

kubectl describe node <node-name>
kubectl top nodes

2. Verifique quais pods estão consumindo mais recursos. Defina recursos e limites para os pods para garantir que eles não estejam consumindo demais. Você também pode impor isso a todos os namespaces do cluster.

kubectl top pods --all-namespaces

3. Diminua as cargas de trabalho não essenciais para liberar recursos.

kubectl scale deployment <deployment-name> --replicas=0

4. Aumente os nós disponíveis para aumentar os recursos do cluster. Você também pode adicionar mais nós ao autoscaler do cluster, se houver um em uso.

Dicas para se preparar para uma entrevista sobre Kubernetes

Com minha própria experiência em entrevistas sobre Kubernetes, aprendi que o sucesso exige mais do que apenas memorizar conceitos. Você precisa aplicar seu conhecimento em cenários do mundo real, solucionar problemas com eficiência e explicar claramente suas soluções.

Se você quiser ter sucesso nas entrevistas do Kubernetes, siga as dicas abaixo:

1. Domine os principais conceitos do Kubernetes. Certifique-se de que você entende de Pods, Implantações, Serviços, Volumes persistentes, ConfigMaps, Segredos, etc.
2. Obtenha experiência prática com o Kubernetes. Quando estava me preparando para as entrevistas, descobri que montar meu próprio cluster Minikube e implementar microsserviços ajudou a reforçar meu entendimento. Você também pode usar um serviço Kubernetes gerenciado de um provedor de nuvem para praticar em escala.
3. Aprenda a depurar problemas do Kubernetes, pois a solução de problemas é uma parte importante do trabalho com o Kubernetes no mundo real. Você provavelmente passará a maior parte do tempo solucionando problemas de aplicativos no trabalho.
• Os problemas típicos que ocorrem incluem pods travados, falhas de rede, volumes persistentes que não estão sendo montados corretamente e falhas de nó.
4. Entenda a rede do Kubernetes e o balanceamento de carga. Concentre-se em como a rede é implementada, como os pods se comunicam, quais tipos de serviço existem e como expor aplicativos.
5. Saiba como dimensionar e otimizar as cargas de trabalho do Kubernetes. Os entrevistadores geralmente perguntam sobre estratégias de escalonamento e otimização de custos. Você deve ser proficiente com HPA, autoscaler de cluster, solicitações de recursos e limites. 
6. Entenda as práticas recomendadas de segurança do Kubernetes. Conhecer o RBAC, o contexto de segurança do POD, as políticas de rede e o gerenciamento de segredos.
7. Estudar a arquitetura e os aspectos internos do Kubernetes. Familiarize-se com os componentes do plano de controle e como o kubelet e o tempo de execução do contêiner interagem.

Ao combinar o conhecimento teórico com a prática e aprender com a solução de problemas do mundo real, você dominará qualquer entrevista sobre o Kubernetes!

Conclusão

O Kubernetes é um sistema de orquestração de contêineres avançado, mas complexo. A entrevista para as funções do Kubernetes requer um profundo entendimento da teoria e da solução de problemas do mundo real. Não importa se você é um engenheiro júnior em busca do primeiro emprego ou um engenheiro sênior que almeja funções mais avançadas, a preparação é sempre fundamental.

Não posso enfatizar o suficiente a importância da prática. Ele ajuda você a encontrar problemas em seus aplicativos com mais rapidez e a ter mais confiança em suas habilidades.

Se você deseja fortalecer seus fundamentos, recomendo explorar cursos como Containerization and Virtualization Concepts para criar uma base sólida, seguido de Introduction to Kubernetes para obter experiência prática com o Kubernetes.

Desejo a você tudo de bom em suas entrevistas!