[Kubernetes] Explicação detalhada do failover e do mecanismo de autocorreção

I. Introdução

1. Introdução ao Kubernetes

O ubernetes é uma plataforma de orquestração de contêineres de código aberto que pode gerenciar automaticamente a implantação, dimensionamento e atualização de contêineres. Ele alivia a carga dos desenvolvedores e melhora a confiabilidade e a escalabilidade do aplicativo. Um dos motivos do sucesso do Kubernetes são seus recursos automatizados de failover e autocorreção, recursos que o tornam uma das plataformas preferidas para o desenvolvimento de aplicativos nativos da nuvem.

2. A importância dos recursos de failover e autocorreção

故障转移功能Permite que o Kubernetes detecte falhas em contêineres, nós, pods e ambientes de cluster inteiros. Assim que uma falha é detectada, ele reinicia automaticamente os contêineres ou reagenda os pods para garantir a disponibilidade do aplicativo. Esse mecanismo de failover automatizado melhora muito a confiabilidade do sistema e reduz o tempo de inatividade do aplicativo.

自愈能力é outro recurso importante do Kubernetes que permite que o Kubernetes repare automaticamente nós, contêineres e pods problemáticos. Quando um nó ou pod falha, o Kubernetes automaticamente os remove temporariamente do cluster e os recria para garantir a disponibilidade do aplicativo. Da mesma forma, quando os nós ou contêineres falham, o Kubernetes pode movê-los automaticamente para outro nó ou reiniciá-los.

Esses recursos reduzem muito a necessidade de intervenção manual e melhoram muito a confiabilidade e a disponibilidade do aplicativo. Eles também podem fornecer às empresas melhor suporte de operação e manutenção e reduzir os custos de gerenciamento. Além disso, a detecção e transferência automatizada de falhas também podem aprimorar os recursos de integração e colaboração com outros serviços, melhorando ainda mais o desempenho geral e a confiabilidade do sistema.

Na era da computação em nuvem, a confiabilidade e escalabilidade do aplicativo tornam-se imperativos na arquitetura técnica. O uso do Kubernetes pode melhorar significativamente a eficiência do desenvolvedor e a confiabilidade do sistema, reduzindo a possibilidade de problemas de falha e interrupções de serviço. Portanto, o Kubernetes, como um sistema de orquestração de contêineres de nova geração, tornou-se uma parte indispensável das empresas modernas.

2. Visão geral do Kubernetes

1. Arquitetura do Kubernetes

A arquitetura do Kubernetes inclui os seguintes componentes:

• Nó mestre:
  controla o status e os processos de todo o cluster e agenda aplicativos.
• Nós de trabalho:
  execute instâncias de contêiner.
• etcd:
  Armazena informações de estado para todo o cluster.

Na arquitetura do Kubernetes, o nó Master é o componente responsável por gerenciar e monitorar todo o cluster. Ele inclui os seguintes componentes principais:

• API Server:
  expõe informações de status do cluster e interfaces que podem ser operadas por meio da interface da API REST. Todos os comandos de controle do Kubernetes são encaminhados para os componentes correspondentes pelo API Server.
• etcd:
  Armazena as informações de estado do cluster. É um sistema de armazenamento de chave-valor altamente confiável e escalável usado pelo Kubernetes para armazenar configuração, estado e metadados para todo o cluster.
• Controller Manager:
  monitora o status do cluster e garante que o estado esperado do sistema seja consistente com o estado real. Ele atinge esse objetivo por meio de vários controladores, como Replication Controller e Endpoint Controller, etc.
• Agendador:
  responsável por atribuir aplicativos a nós de trabalho e organizar a localização de instâncias de contêiner de acordo com a política de agendamento.

Nós de trabalho são nós de computação no cluster Kubernetes que executam instâncias de contêiner e são responsáveis ​​por monitorar essas instâncias de contêiner. Inclui os seguintes componentes:

• kubelet:
  monitore o status de execução das instâncias do contêiner e relate as informações de status ao nó mestre. Ele também analisa as informações de especificação do contêiner para garantir que o contêiner esteja configurado corretamente e executa o aplicativo dentro do contêiner.
• kube-proxy:
  Proxy de rede, responsável por manter as regras de rede do cluster e rotear as solicitações de rede para onde elas devem ir. Ele implementa balanceamento de carga interno por meio de iptables e responde a solicitações de verificação de "saúde" de balanceadores de carga externos com o protocolo ICMP.

2. Componentes e funções do Kubernetes

O Kubernetes fornece os seguintes componentes e recursos para melhor gerenciamento e operação de aplicativos em contêineres:

• Pod:
  Pod é a unidade mais básica do Kubernetes, que é uma coleção de um ou mais contêineres. O pod possui endereço IP separado e ambiente independente, e o espaço de rede é compartilhado entre contêineres, que podem ser compartilhados por meio de recursos como IPC e Volum.
• Serviço:
  Serviço é um mecanismo de comunicação em rede entre contêineres, podendo mapear um grupo de contêineres do mesmo tipo e fornecer funções como balanceamento de carga e descoberta de serviços. O serviço fornece diferentes tipos de serviço por meio de ClusterIP, NodePort e LoadBalancer.
• Volume:
  Volume é a abstração de armazenamento do contêiner, que pode ser usado para dados persistentes ou armazenamento compartilhado.
• ReplicaSet: o
  ReplicaSet garante que o número de Pods em um grupo sempre atenda ao número especificado de réplicas, que pode ser usado para garantir a autocorreção e a disponibilidade dos aplicativos em caso de falha.
• Implantação:
  a implantação é uma extensão do ReplicaSet, que fornece funções como atualização sem interrupção e reversão.
• StatefulSet:
  StatefulSet é uma sequência de Pods. Cada Pod possui um identificador de rede independente e é identificável. Ele pode ser usado para aplicativos que requerem armazenamento persistente, implantação ordenada ou sistemas de armazenamento integrados.
• ConfigMap e Secret:
  ConfigMap e Secret são objetos que separam as informações de configuração e senha do código-fonte do aplicativo e podem ser montados em instâncias de contêiner sem serem expostos a variáveis ​​de ambiente ou código.

Em geral, o Kubernetes fornece muitas funções que tornam a implantação, operação e manutenção de aplicativos em contêineres mais convenientes. Com o Kubernetes, você pode facilmente dimensionar aplicativos, obter balanceamento de carga, garantir alta disponibilidade e executar operações como atualizações e reversões contínuas. Além disso, a funcionalidade e a eficiência dos aplicativos conteinerizados podem ser aprimoradas ainda mais por meio de alta integração com outras ferramentas e plataformas nativas da nuvem, como ISTIO e Operator Framework.

3. Failover

1. Como definir failover

Failover significa que, quando um sistema ou aplicativo falha, ele transfere ou redistribui automaticamente a carga de trabalho para outros nós ou instâncias disponíveis para manter a disponibilidade e a continuidade dos serviços. O failover é um recurso fundamental da computação em nuvem e dos sistemas distribuídos, ajudando os aplicativos a manter sua funcionalidade e garantir uma operação suave.

Os mecanismos de failover incluem coordenar e monitorar o status dos nós do aplicativo e restaurá-los automaticamente para a operação normal no caso de falha na manutenção da confiabilidade do serviço. Para atingir o failover, os sistemas e aplicativos podem empregar estratégias de backup e redundância, como armazenamento de backup e sistemas tolerantes a falhas.

2. Mecanismo de failover no Kubernetes

O Kubernetes é um sistema de orquestração de contêineres de código aberto que pode ser usado para automatizar a implantação, dimensionamento e gerenciamento de aplicativos em contêineres. Ele fornece vários mecanismos de failover para garantir que os aplicativos permaneçam disponíveis e continuem a ser executados em caso de falha.

A seguir está o mecanismo de failover no Kubernetes:

2.1 Verificação de saúde

As verificações de integridade são uma parte essencial do mecanismo de failover do Kubernetes. Ele verifica periodicamente o status do aplicativo ou do pod dentro do contêiner para detectar falhas ou travamentos a tempo e reinicia ou reconstrói automaticamente os pods com falha.

Existem três tipos de verificações de saúde:

• livenessProbe: verifica se o aplicativo dentro do contêiner está ativo e responde às solicitações.
• readinessProbe: verifica se o aplicativo dentro do contêiner está pronto para aceitar tráfego de rede.
• startupProbe: verifica se o aplicativo dentro do contêiner está iniciando e aguarda um pouco antes que a inicialização seja concluída.

2.2 Pods e ReplicaSets

O pod é a menor unidade de implantação no Kubernetes. Ele pode conter um ou mais contêineres e fornece um ambiente para compartilhamento de armazenamento e recursos de rede.

ReplicaSet é outro conceito importante no Kubernetes. Ele é usado para gerenciar as réplicas de Pods e garantir que o número necessário de Pods esteja sempre em execução.

Se um Pod falhar ou for encerrado, o ReplicaSet iniciará automaticamente um novo Pod para substituí-lo. Isso garante que os aplicativos de contêiner estejam sempre disponíveis no tempo de execução.

2.3 Controladores e failover

No Kubernetes, um controlador é uma abstração de alto nível usada para gerenciar Pods e ReplicaSets e garantir que seus aplicativos se comportem conforme o esperado. O Kubernetes fornece uma variedade de tipos de controladores, incluindo Deployment, StatefulSet e DaemonSet.

Um controlador pode monitorar o status de Pods e ReplicaSets e fazer failover ou recriá-los conforme necessário. Por exemplo, um controlador de implantação pode aumentar ou diminuir automaticamente o número de pods para garantir que seu aplicativo tenha recursos suficientes.

3. A relação entre Pods e ReplicaSets

Pod é a menor unidade de implantação no Kubernetes, que pode conter um ou mais contêineres e fornecer um ambiente para compartilhamento de armazenamento e recursos de rede. Um ReplicaSet é uma abstração para gerenciar réplicas de pods e garantir que o número necessário de pods esteja em execução.

A relação entre Pod e ReplicaSet é a seguinte:

• Cada Pod é gerenciado por um ReplicaSet e deve ser atribuído a um ReplicaSet quando é criado.
• Um ReplicaSet determina o número necessário de pods e automaticamente cria, exclui e reconstrói pods quando necessário.
• Um ReplicaSet pode identificar instantaneamente um pod com falha e substituí-lo por um novo.

4. Controladores e Failover

No Kubernetes, um controlador é uma abstração de alto nível usada para gerenciar Pods e ReplicaSets e garantir que seus aplicativos se comportem conforme o esperado. O Kubernetes fornece uma variedade de tipos de controladores, incluindo Deployment, StatefulSet e DaemonSet.

O controlador pode monitorar o status de Pods e ReplicaSets e realizar failover ou recriação conforme necessário. Por exemplo, se um Pod falhar ou for excluído, o controlador de implantação pode criar automaticamente um novo Pod e garantir que o aplicativo permaneça disponível enquanto estiver em execução.

Além disso, os controladores podem usar recursos de implantação contínua para garantir que os aplicativos sejam atualizados sem interrupção do serviço. Ele alterna novas versões de pods com base na disponibilidade e nas políticas de balanceamento de carga para garantir que não haja falhas durante as atualizações do aplicativo.

4. Capacidade de autocura

1. Como definir a capacidade de autocura

A capacidade de autocorreção refere-se à capacidade de um sistema ou aplicativo de monitorar e reparar a si mesmo para melhorar a disponibilidade e a confiabilidade do sistema. Quando ocorre uma falha ou situação anormal, a capacidade de autocorreção pode detectar e lidar automaticamente com o problema, reduzindo a necessidade de intervenção manual, de modo a restaurar rapidamente o estado normal de trabalho. Isso pode melhorar a disponibilidade do sistema e garantir a operação contínua e estável do sistema.

Os recursos de autocorreção são a base dos aplicativos distribuídos modernos. Em áreas como computação em nuvem, tecnologia de contêineres e arquitetura de microsserviços, aplicativos complexos e de grande escala se tornaram a norma. Esses aplicativos contêm muitos componentes e serviços com dependências complexas entre eles. Quando um dos componentes ou serviços falha, é provável que afete o funcionamento normal de todo o aplicativo.

Portanto, os recursos de autocorreção tornaram-se um recurso essencial em aplicativos modernos. Esse recurso pode reduzir a necessidade de intervenção humana e melhorar a disponibilidade e a estabilidade do aplicativo.

2. Mecanismo de autocorreção no Kubernetes

O Kubernetes é um sistema popular de orquestração de contêineres que fornece uma série de mecanismos de autocorreção para garantir a disponibilidade e a confiabilidade dos aplicativos de contêineres. A seguir estão alguns mecanismos comuns de autocorreção do Kubernetes:

2.1 Atualização contínua automática

As atualizações contínuas são uma forma de atualizar os aplicativos no Kubernetes. Ele usa duas versões do aplicativo para atualizar incrementalmente todos os contêineres para evitar interrupções e falhas momentâneas do serviço. Uma atualização contínua inicia a nova versão do contêiner do aplicativo e interrompe gradualmente a versão antiga até que todos os contêineres tenham sido atualizados.

2.2 Expansão e contração automática

O Kubernetes pode ajustar automaticamente o número de réplicas de acordo com a carga do aplicativo para garantir a disponibilidade do sistema. Quando a carga fica alta, aumenta automaticamente o número de réplicas; quando a carga fica muito baixa, diminui automaticamente o número de réplicas. Esse mecanismo adaptativo de expansão e contração pode garantir a estabilidade e a disponibilidade do sistema.

2.3 Tolerância automática a falhas

O Kubernetes possui uma série de mecanismos de tolerância a falhas, incluindo reinicialização de pod, reinicialização de contêiner, reinicialização de nó, etc. Esses mecanismos podem garantir que o aplicativo possa se recuperar rapidamente para um estado normal em caso de falha.

2.4 Configuração de atualização automática

O Kubernetes pode atualizar automaticamente a configuração do aplicativo para garantir que o aplicativo tenha a configuração mais recente em tempo de execução. Este processo de atualização é muito seguro, pois garantirá que todos os Pods foram iniciados com sucesso, não interrompendo ou perdendo nenhuma requisição durante o processo.

2.5 Reparação Automática

O Kubernetes possui alguns mecanismos de autocorreção que podem detectar e reparar automaticamente falhas ou condições anormais nos pods. Esses mecanismos incluem sondagens de ativação e prontidão, verificações de integridade do pod e muito mais.

3. Monitoramento de integridade do pod

O monitoramento Podde integridade refere-se ao monitoramento da integridade de cada contêiner em um pod. Quando um contêiner estiver anormal, o Kubernetes reiniciará automaticamente o contêiner ou o pod inteiro de acordo com a configuração. Esse mecanismo de monitoramento de integridade pode garantir que o aplicativo possa se recuperar rapidamente para um estado normal em caso de falha.

Quando o Kubernetes determina que o contêiner dentro do pod está com defeito, ele reinicia automaticamente o contêiner por meio de um mecanismo de autocorreção para restaurar o máximo possível de contêineres à operação normal. Se a recuperação não for possível, toda a instância do pod será eliminada. Este mecanismo evita a necessidade de intervenção manual do pessoal de operação e manutenção, tornando a automação mais perfeita.

4. O que são sondagens de vivacidade e prontidão

LivenessA sonda monitora se o contêiner ainda está em execução e, se a sonda falhar, o Kubernetes encerra o contêiner e reinicia um novo. A sonda Liveness é usada dentro do contêiner para resolver problemas como animação suspensa do processo e impasse. O probe Liveness detecta o status de execução de um contêiner enviando uma solicitação ao console do contêiner. Se o probe receber uma resposta, o contêiner está íntegro; caso contrário, o contêiner pode ter um problema e precisar ser reiniciado.

Readiness 探针监测容器Se uma solicitação externa foi recebida. Se a investigação falhar, o Kubernetes para de enviar tráfego para o contêiner, evitando assim o envio de solicitações ao contêiner com falha. O probe Readiness é usado para resolver o problema de que o contêiner não pode receber solicitações imediatamente quando é iniciado.

Em conclusão, a capacidade de autocorreção é uma característica essencial dos aplicativos modernos. O Kubernetes fornece uma série de mecanismos de autocorreção, incluindo atualização contínua automática, expansão e contração automáticas, tolerância automática a falhas, reparo automático e configuração de atualização automática. O monitoramento da integridade do pod e as investigações de vivacidade e prontidão também são mecanismos de autocorreção muito importantes no Kubernetes. Esses mecanismos podem reduzir a necessidade de intervenção humana e aumentar a disponibilidade e estabilidade dos aplicativos.
O conteúdo acima é gerado em um bloco de código com sintaxe marknow

5. Depuração no Kubernetes

1. Fazendo login no Kubernetes

No Kubernetes, o log é uma parte muito importante. Muitos componentes em um cluster Kubernetes fornecem níveis variados de log que podem informar o que está acontecendo no cluster e ajudá-lo a encontrar possíveis problemas. Aqui estão alguns componentes comuns do Kubernetes e seus locais de registro correspondentes:

• kube-apiserver: por padrão, o local de log do kube-apiserver é /var/log/kube-apiserver.log.
• kube-controller-manager: por padrão, o local de log do kube-controller-manager é /var/log/kube-controller-manager.log.
• kube-scheduler: por padrão, o local de log do kube-scheduler é /var/log/kube-scheduler.log.
• kubelet: kubelet produzirá logs para stdout e /var/log/kubelet.log.
• kube-proxy: o local de log padrão para kube-proxy é /var/log/kube-proxy.log.

Além de registrar os componentes acima, há alguns outros locais de registro a serem considerados. Por exemplo, os aplicativos executados em contêineres normalmente registram em stdout ou stderr, que é então coletado pelo Kubernetes e gravado em seus logs de pod.

Os logs do pod podem ser acessados ​​usando comandos kubectl, por exemplo:

kubectl logs <pod-name>

Além disso, existem ferramentas que ajudam a coletar e visualizar logs do Kubernetes. Por exemplo, o Elasticsearch e o Kibana podem ser usados ​​para diagnóstico e análise centralizados de logs do Kubernetes.

2. Failover de depuração e recursos de autocorreção

O Kubernetes fornece muitos recursos de failover e autocorreção, incluindo:

• Reiniciar contêineres automaticamente: se um contêiner travar, o Kubernetes reiniciará automaticamente o contêiner, o que ajuda a manter a estabilidade do aplicativo.
• Dimensionamento automático de pods: o Kubernetes pode dimensionar pods automaticamente com base em métricas como a utilização da CPU para atender às necessidades dos aplicativos.
• Failover automático: se um nó ou pod travar, o Kubernetes migrará automaticamente o nó ou pod para outros nós e restaurará o serviço para o aplicativo o mais rápido possível.

No entanto, quando o Kubernetes falha em resolver falhas automaticamente, os problemas precisam ser rastreados e depurados manualmente. Aqui estão algumas dicas comuns de depuração:

• Exibir status do pod: você pode usar o comando kubectl para visualizar o status dos pods, por exemplo:

kubectl get pods

Isso listará todos os pods e seus status atuais.

• Visualizar eventos: você pode usar o comando kubectl para visualizar eventos que ocorrem no cluster, por exemplo:

kubectl get events

Isso listará todos os eventos publicados no cluster.

• Exportar registros do pod: quando um pod está em um estado anormal, você pode usar o comando kubectl para exportar logs do pod, por exemplo:

kubectl logs <pod-name> > pod.log

Isso exportará os logs do pod para o arquivo pod.log para facilitar a análise.

• Depurando o contêiner: você pode usar o comando kubectl exec para executar comandos dentro do contêiner, por exemplo:

kubectl exec <pod-name> <container-name> -- <command>

Isso executará o comando dentro do contêiner.

No Kubernetes, os recursos de failover e autocorreção de log e depuração são muito importantes. Ao monitorar logs e eventos em seu cluster, você pode identificar rapidamente problemas e depurar aplicativos. Os recursos automáticos de failover e autocorreção do Kubernetes podem nos ajudar a manter a estabilidade do aplicativo, mas quando o Kubernetes não consegue resolver problemas automaticamente, o rastreamento manual e a depuração de problemas são necessários.

6. Melhore os recursos de failover e autocorreção

1. Melhores práticas e ferramentas

No Kubernetes, para melhorar os recursos de failover e autocorreção, as seguintes práticas e ferramentas recomendadas podem ser adotadas:

1.1 Use a verificação de saúde:

A configuração do Liveness Probe e do Readiness Probe no contêiner pode verificar periodicamente o status de integridade do contêiner e reiniciar ou encerrar o contêiner de acordo com a situação. Isso ajuda a evitar que a falha de um único contêiner desative todo o aplicativo.

Para usar as verificações de integridade:

1. Crie uma implantação ou pod do Kubernetes.

2. Defina verificações de integridade em implantações ou pods.

3. Execute a implantação ou pod.

1.1.1 Código de exemplo para uma implantação usando verificações de integridade HTTP:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: example-container
        image: example-image
        ports:
        - containerPort: 80
        livenessProbe:
          httpGet:
            path: /healthz
            port: 80
          periodSeconds: 5
          initialDelaySeconds: 15

Neste exemplo, definimos uma implantação chamada example-deployment que cria três réplicas, cada uma contendo um contêiner chamado example-container. O contêiner usa image: example-image e escuta na porta 80. Além disso, definimos uma verificação de integridade HTTP que verifica se o terminal /healthz do contêiner está disponível. O livenessProbe informa ao Kubernetes para verificar a integridade do contêiner a cada 5 segundos e não iniciar até 15 segundos após o início do contêiner.

4. Você pode usar a ferramenta de linha de comando kubectl para executar a implantação acima:

kubectl apply -f example-deployment.yaml

Neste ponto, o Kubernetes criará a implantação, que inclui três pods e um serviço. O Kubernetes começará a verificar a integridade dos contêineres e reiniciá-los se eles não estiverem íntegros.

1.2 Executar várias cópias:

O Kubernetes pode melhorar a disponibilidade e a confiabilidade dos aplicativos executando várias réplicas. Isso significa que, se um pod falhar, o Kubernetes pode escalar automaticamente as réplicas e iniciar novos pods, garantindo que o aplicativo esteja sempre funcionando no cluster.

1.1.2 Etapas da operação para executar várias réplicas usando o Kubernetes:

1. Crie uma implantação ou StatefulSet.

2. Defina o número de réplicas no arquivo YAML.

3. Execute a implantação ou StatefulSet.

Aqui está um exemplo de código para uma implantação com 3 réplicas:

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

Neste exemplo, definimos uma implantação chamada example-deployment e especificamos sua contagem de réplicas como 3 na especificação. Em seguida, definimos um container chamado example-container que usa image: example-image e escuta na porta 80.

4. Você pode usar a ferramenta de linha de comando kubectl para executar a implantação acima:

kubectl apply -f example-deployment.yaml

O Kubernetes iniciará 3 réplicas, cada uma contendo um contêiner de exemplo. Em seguida, o Kubernetes pode transferir automaticamente a carga de trabalho para que o conjunto de agendamento seja executado sem falhas. Se um dos pods não funcionar normalmente, o Kubernetes iniciará um novo pod para substituí-lo.

É assim que o Kubernetes pode melhorar a disponibilidade e a confiabilidade dos aplicativos simplesmente executando várias réplicas.

1.3 Usar expansão automática:

Os recursos de escalonamento automático do Kubernetes podem ajudar a lidar com alto tráfego, alta simultaneidade e outras cargas, garantindo que seus aplicativos estejam sempre funcionando com desempenho máximo.

1.1.3 Etapas da operação para usar o Kubernetes para expandir a capacidade automaticamente:

1. Crie uma implantação ou StatefulSet.

2. Defina limites de CPU e/ou memória em um arquivo YAML.

3. Configurar regras de dimensionamento automático.

4. Execute a implantação ou StatefulSet.

Veja a seguir um exemplo de código para uma implantação que aumenta automaticamente com base no uso da CPU:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: example-container
        image: example-image
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: "500m"
          requests:
            cpu: "200m"
        readinessProbe:
          httpGet:
            path: /healthz
            port: 80
          periodSeconds: 5
          initialDelaySeconds: 15
        livenessProbe:
          httpGet:
            path: /healthz
            port: 80
          periodSeconds: 5
          initialDelaySeconds: 15
      autoscaler:
        targetCPUUtilizationPercentage: 80
        minReplicas: 3
        maxReplicas: 10

Neste exemplo, definimos uma implantação chamada example-deployment e especificamos o número de réplicas como 3 na especificação. Em seguida, definimos um contêiner que usa image: example-image e escuta na porta 80. Além dos contêineres, também definimos um objeto HorizontalPodAutoscaler, que configura regras de dimensionamento automático para ajustar o número de réplicas com base no uso da CPU.

O campo targetCPUUtilizationPercentage do autoescalador define o valor de destino de uso da CPU como 80%, minReplicas define o número mínimo de instâncias de pod como 3 e maxReplicas define o número máximo de instâncias de pod como 10. Isso significa que, quando o uso da CPU exceder 80%, o Kubernetes escalará automaticamente a implantação em 3 instâncias de pod para atingir um máximo de 10 réplicas.

5. Você pode usar a ferramenta de linha de comando kubectl para executar a implantação acima:

kubectl apply -f example-deployment.yaml

O Kubernetes criará 3 réplicas e dimensionará automaticamente a implantação à medida que a carga aumenta, garantindo que seu aplicativo esteja sempre funcionando de maneira ideal.

1.4 Liberação em escala de cinza:

A distribuição em escala de cinza é um método de introdução incremental de novas versões de um aplicativo na produção. Ele pode ajudar a reduzir o risco de falha e aumentar a disponibilidade do aplicativo. O Kubernetes fornece alguns objetos de recursos, como implantação e serviço, que podem ser usados ​​para implementar a liberação em escala de cinza.

1.1.4 Etapas da operação para usar a versão em escala de cinza do Kubernetes:

1. Crie duas implantações, uma para o aplicativo antigo e outra para o novo aplicativo.

2. Defina um serviço no balanceador de carga e aponte-o para o antigo pod de implantação.

3. Teste a funcionalidade e o desempenho do novo aplicativo sequencialmente, alterando incrementalmente o serviço para apontar para os novos pods de implantação.

Veja a seguir um exemplo de código publicado usando tons de cinza:

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

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: new-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: new-app
  template:
    metadata:
      labels:
        app: new-app
    spec:
      containers:
      - name: new-app-container
        image: new-app-image
        ports:
        - containerPort: 80

---

apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  type: LoadBalancer
  selector:
    app: old-app
  ports:
  - name: http
    port: 80
    targetPort: 80

Neste exemplo, definimos duas implantações, uma para o aplicativo antigo denominado old-app e outra para o novo aplicativo denominado new-app. Também definimos um serviço chamado app-service, o configuramos como um tipo de balanceador de carga e o apontamos para o pod do aplicativo antigo. Isso direcionará todo o tráfego para os pods no aplicativo antigo.

Em seguida, podemos alterar gradualmente a definição do serviço para apontar para o novo pod do aplicativo. Você pode fazer isso com a ferramenta de linha de comando kubectl:

Neste exemplo, definimos duas implantações, uma para o aplicativo antigo denominado old-app e outra para o novo aplicativo denominado new-app. Também definimos um serviço chamado app-service, o configuramos como um tipo de balanceador de carga e o apontamos para o pod do aplicativo antigo. Isso direcionará todo o tráfego para os pods no aplicativo antigo.

Em seguida, podemos alterar gradualmente a definição do serviço para apontar para o novo pod do aplicativo. Você pode fazer isso com a ferramenta de linha de comando kubectl:

kubectl apply -f new-service.yaml

Isso usará o serviço da nova definição para encaminhar o tráfego para os novos pods do aplicativo. Com o tempo, você pode aumentar gradualmente o número de réplicas do novo aplicativo e transferir o tráfego para o novo aplicativo para testar mais completamente seu desempenho e funcionalidade.

1.5 Backup e restauração da configuração:

O Kubernetes oferece suporte fácil para backup e restauração de configurações de aplicativos mapeando ConfigMaps e Secrets para Pods. Isso pode ajudar a evitar erros durante a restauração.

1.1.5 Etapas da operação para usar o backup e a recuperação da configuração do Kubernetes:

O backup e a recuperação da configuração do Kubernetes podem ajudá-lo a proteger melhor seus aplicativos e dados de configuração em caso de situações inesperadas. Aqui estão as etapas para configurar o backup e a restauração usando o Kubernetes:

1. Crie arquivos de configuração.

2. Arquivos de configuração de backup.

3. Restaurar arquivos de configuração.

Aqui está um exemplo de um arquivo de configuração básico:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  app.properties: |
    database.url=jdbc:mysql://localhost/mydb
    database.username=admin
    database.password=secret

Neste exemplo, definimos um objeto ConfigMap chamado app-config. Ele contém um par chave-valor chamado app.properties que contém detalhes de configuração para o aplicativo, URL do banco de dados, nome de usuário e senha e assim por diante.

Para fazer backup dos arquivos de configuração, você pode usar a ferramenta de linha de comando kubectl para fazer backup do objeto ConfigMap em um arquivo YAML:

kubectl get configmaps app-config -o yaml > app-config.yaml

Isso exportará o objeto ConfigMap denominado app-config para o arquivo app-config.yaml para que possa ser restaurado posteriormente. Você pode fazer backup de mais recursos, como implantação e StatefulSet, conforme necessário.

Para restaurar o arquivo de configuração, você pode importar o arquivo de backup de volta para o Kubernetes usando a ferramenta de linha de comando kubectl:

kubectl apply -f app-config.yaml

Isso criará um novo objeto ConfigMap e importará os pares chave-valor definidos no arquivo app-config.yaml de volta para o objeto.

1.6 Usar classe de armazenamento:

O Kubernetes fornece diferentes tipos de classes de armazenamento, como Persistent Volume e StorageClass, que podem ser usados ​​para implementar armazenamento persistente e compartilhamento de dados entre contêineres. Eles ajudam os dados a serem protegidos contra migrações de aplicativos e falhas de nós.

1.1.6 Etapas da operação para usar Kubernetes para usar classes de armazenamento:

A seguir está o processo de operação básica do uso de classes de armazenamento:

1. Crie uma classe de armazenamento.

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-storage-class
provisioner: my-provisioner

em que my-storage-class é o nome da classe de armazenamento e my-provisioner é o nome de um subsistema de volume dinâmico.

2. Use classes de armazenamento em pods.

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    volumeMounts:
    - mountPath: "/usr/share/nginx/html"
      name: my-volume
  volumes:
  - name: my-volume
    persistentVolumeClaim:
      claimName: my-claim

em que my-claim é o nome de uma declaração de volume persistente usando a classe de armazenamento.

3. Cria um objeto de declaração de volume persistente que usará a classe de armazenamento para fornecer armazenamento persistente.

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

em que my-claim é o nome da declaração de volume persistente e my-storage-class é o nome da classe de armazenamento usada.

2. A execução de aplicativos por meio do Kubernetes leva a sistemas mais confiáveis

Kubernetes é uma tecnologia automatizada de conteinerização que gerencia e executa aplicativos em sistemas distribuídos. As principais vantagens desta técnica são:

• Recursos como configuração automática de nós, descoberta de serviço e recuperação de falhas.
• Apoie a expansão horizontal, melhorando assim a tolerância a falhas e a capacidade de carga do sistema.
• A implantação de código pode ser feita usando atualizações contínuas, evitando interrupções de aplicativos e tempo de inatividade.
• Fornece balanceador de carga automatizado e descoberta de serviço para otimizar o tráfego e o roteamento da rede.
• Integre várias ferramentas de monitoramento para detectar e resolver erros e falhas em aplicativos em tempo real.

7. Conclusão

1. Resuma os pontos-chave

No geral, este artigo descreve as várias maneiras pelas quais o Kubernetes pode melhorar os recursos de failover e autocorreção, incluindo o uso de verificações de integridade, execução de várias réplicas, dimensionamento automático e implementação em escala de cinza e configuração de backup e recuperação. Esses métodos são projetados para garantir que o aplicativo esteja sempre disponível e possa se recuperar automaticamente de falhas quando elas forem encontradas.

Com o desenvolvimento da computação em nuvem e o aumento da complexidade dos aplicativos, torna-se cada vez mais importante melhorar a disponibilidade e a resiliência dos aplicativos. Ao usar esses métodos fornecidos pelo Kubernetes, ele pode ajudar as empresas a gerenciar e proteger melhor seus aplicativos e dados, de modo a atender melhor às necessidades e requisitos dos usuários.

2. Pensando no futuro

No futuro, à medida que a tecnologia continua avançando e os aplicativos evoluem, o Kubernetes pode se tornar cada vez mais inteligente e adotar uma abordagem mais adaptável e de autocorreção para melhorar os recursos de failover e autocorreção. Tornar-se-á cada vez mais importante para empresas e indivíduos entender e dominar esses métodos fornecidos pelo Kubernetes, a fim de lidar com o ambiente de aplicativos e tecnologia em constante mudança.