Explicação detalhada do gerenciamento de cache de imagem K8s desenvolvido pelo kube

Este artigo foi compartilhado pela comunidade Huawei Cloud " K8s Image Cache Management Kube-fledged Awareness " por Shanhe.

Sabemos que o agendamento de contêineres na Internet precisa extrair a imagem do contêiner atual na linha do nó agendado. Em alguns cenários especiais, k8s 

  • 快速启动和/或扩展 Aplicação necessária . Por exemplo, os aplicativos que realizam processamento de dados em tempo real precisam ser dimensionados rapidamente devido à explosão dos volumes de dados.
  • A imagem é relativamente grande e envolve múltiplas versões. O armazenamento do nó é limitado e as imagens desnecessárias precisam ser limpas dinamicamente.
  • 无服务器函数 Muitas vezes é necessário reagir imediatamente aos eventos recebidos e iniciar os contêineres em uma fração de segundo.
  • A execução de dispositivos de borda precisa tolerar conectividade de rede intermitente com o repositório espelhado.   IoT 应用程序 边缘设备
  • Se você precisar extrair uma imagem 专用仓库 de , e não puder conceder 镜像仓库 acesso a todos para extrair a imagem de lá, você poderá disponibilizar a imagem nos nós do cluster.
  • Se um administrador ou operador de cluster precisar atualizar um aplicativo e quiser verificar antecipadamente se a nova imagem pode ser extraída com êxito.

kube-fledged Ele é usado para criar e gerenciar cache de imagens de contêiner diretamente nos nós do cluster Kubernetes . Ele permite que os usuários definam uma lista de imagens e em quais nós de trabalho essas imagens devem ser armazenadas em cache (ou seja, extraídas). Como resultado, o pod do aplicativo pode ser iniciado quase imediatamente porque não há necessidade de extrair a imagem do registro. kubernetes operator worker 

kube-fledged Uma API CRUD é fornecida para gerenciar o ciclo de vida do cache de imagem e oferece suporte a vários parâmetros configuráveis, permitindo personalizar funções de acordo com suas próprias necessidades.

O Kubernetes possui o 镜像垃圾回收机制. O kubelet no nó verifica periodicamente se o uso do disco atinge um determinado limite (configurável por meio de sinalizadores). Quando isso for alcançado 阈值, o kubelet excluirá automaticamente todas as imagens não utilizadas do nó.

Mecanismos de atualização automática e periódica precisam ser implementados na solução proposta. Se a imagem no cache de imagens for excluída pelo gc do kubelet, o próximo ciclo de atualização puxará a imagem excluída para o cache de imagens. Isso garante que o cache de imagens esteja atualizado.

Fluxo de projeto

https://github.com/senthilrch/kube-fledged/blob/master/docs/kubefledged-architecture.png

Implantar kube desenvolvido

Implantação do modo Helm

──[[email protected]]-[~/ansible]
└─$mkdir kube de pleno direito
┌──[[email protected]]-[~/ansible]
└─$cd kube de pleno direito
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$exportar KUBEFLEDGED_NAMESPACE = desenvolvido pelo kube
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$kubectl cria espaço para nome ${KUBEFLEDGED_NAMESPACE}
namespace/kube-fledged criado
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$helm repo adicionar kubefledged-charts https://senthilrch.github.io/kubefledged-charts/
"kubefledged-charts" foi adicionado aos seus repositórios
┌──[[email protected]]-[~/ansible/kube-fledged]
└─ atualização do repositório $helm
Aguarde enquanto pegamos as últimas novidades de seus repositórios de gráficos...
...Recebi com sucesso uma atualização do repositório de gráficos "kubefledged-charts"
...Recebi uma atualização do repositório de gráficos "kubescape" com sucesso
...Recebi com sucesso uma atualização do repositório de gráficos "rancher-stable"
...Recebi uma atualização do repositório de gráficos "skm" com sucesso
...Recebi com sucesso uma atualização do repositório de gráficos "openkruise"
...Recebi uma atualização do repositório de gráficos "awx-operator" com sucesso
...Recebi uma atualização do repositório de gráficos "botkube" com sucesso
Atualização completa. ⎈Feliz Helming!⎈
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$helm install --verify kube-fledged kubefledged-charts/kube-fledged -n ${KUBEFLEDGED_NAMESPACE} --wait

Durante a implantação real, descobriu-se que devido a problemas de rede, chart o download não pôde ser feito, por isso foi implantado usando yaml. make deploy-using-yaml 

Implantação de arquivo Yaml

┌──[[email protected]]-[~/ansible/kube-fledged]
└─$git clone https://github.com/senthilrch/kube-fledged.git
Clonagem para 'kube' ...
remoto: Enumerando objetos: 10613, concluído.
remoto: Contagem de objetos: 100% (1501/1501), concluído.
remoto: Compactando objetos: 100% (629/629), pronto.
remoto: Total 10613 (delta 845), reutilizado 1357 (delta 766), pacote reutilizado 9112
Entre objetos receptores: 100% (10613/10613), 34,58 MiB | 7,33 MiB/s, concluído.
Processamento médio delta: 100% (4431/4431), concluído.
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$ls
kube de pleno direito
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$cd kube desenvolvido/
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged]
└─$make implantar usando yaml
kubectl apply -f implantar/kubefledged-namespace.yaml

Ao implantar pela primeira vez, descobri que não era possível extrair a imagem.

┌──[[email protected]]-[~]
└─$kubectl obtenha tudo -n kube desenvolvido
NOME PRONTO STATUS REINICIA IDADE
pod/kube-fledged-controller-df69f6565-drrqg 0/1 CrashLoopBackOff 35 (5h59m atrás) 21h
pod/kube-fledged-webhook-server-7bcd589bc4-b7kg2 0/1 Init:CrashLoopBackOff 35 (5h58m atrás) 21h
pod/kubefledged-controller-55f848cc67-7f4rl 1/1 Executando 0 21h
pod/kubefledged-webhook-server-597dbf4ff5-l8fbh 0/1 Init:CrashLoopBackOff 34 (6h atrás) 21h

NOME TIPO CLUSTER-IP EXTERNAL-IP PORTA(S) IDADE
serviço/servidor kube-fledged-webhook ClusterIP 10.100.194.199 <nenhum> 3443/TCP 21h
serviço/kubefledged-webhook-server ClusterIP 10.101.191.206 <nenhum> 3443/TCP 21h

NOME PRONTO ATUALIZADO DISPONÍVEL IDADE
implantação.apps/kube-fledged-controller 0/1 1 0 21h
implantação.apps/kube-fledged-webhook-server 0/1 1 0 21h
implantação.apps/kubefledged-controller 0/1 1 0 21h
implantação.apps/kubefledged-webhook-server 0/1 1 0 21h

NOME DESEJADO ATUAL PRONTO IDADE
replicaset.apps/kube-fledged-controller-df69f6565 1 1 0 21h
replicaset.apps/kube-fledged-webhook-server-7bcd589bc4 1 1 0 21h
replicaset.apps/kubefledged-controller-55f848cc67 1 1 0 21h
replicaset.apps/kubefledged-webhook-server-597dbf4ff5 1 1 0 21h
┌──[[email protected]]-[~]
└─$

Aqui encontramos a imagem que queremos extrair

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$gato *.yaml | imagem grep:
      - imagem: senthilrch/kubefledged-controller:v0.10.0
      - imagem: senthilrch/kubefledged-webhook-server:v0.10.0
      - imagem: senthilrch/kubefledged-webhook-server:v0.10.0

Extraia alguns individualmente e atualmente use operações em lote em todos os nós de trabalho. ansible 

┌──[[email protected]]-[~/ansible]
└─$ansible k8s_node -m shell -a "docker pull docker.io/senthilrch/kubefledged-cri-client:v0.10.0" -i host.yaml

Extraia outras imagens relacionadas

Após a conclusão da operação, o status do contêiner estará normal.

┌──[[email protected]]-[~/ansible]
└─$kubectl -n kube-fledged pegue tudo
NOME PRONTO STATUS REINICIA IDADE
pod/kube-fledged-controller-df69f6565-wdb4g 1/1 Executando 0 13h
pod/kube-fledged-webhook-server-7bcd589bc4-j8xxp 1/1 Executando 0 13h
pod/kubefledged-controller-55f848cc67-klxlm 1/1 Executando 0 13h
pod/kubefledged-webhook-server-597dbf4ff5-ktbsh 1/1 Executando 0 13h

NOME TIPO CLUSTER-IP EXTERNAL-IP PORTA(S) IDADE
serviço/servidor kube-fledged-webhook ClusterIP 10.100.194.199 <nenhum> 3443/TCP 36h
serviço/kubefledged-webhook-server ClusterIP 10.101.191.206 <nenhum> 3443/TCP 36h

NOME PRONTO ATUALIZADO DISPONÍVEL IDADE
implantação.apps/kube-fledged-controller 1/1 1 1 36h
implantação.apps/kube-fledged-webhook-server 1/1 1 1 36h
implantação.apps/kubefledged-controller 1/1 1 1 36h
implantação.apps/kubefledged-webhook-server 1/1 1 1 36h

NOME DESEJADO ATUAL PRONTO IDADE
replicaset.apps/kube-fledged-controller-df69f6565 1 1 1 36h
replicaset.apps/kube-fledged-webhook-server-7bcd589bc4 1 1 1 36h
replicaset.apps/kubefledged-controller-55f848cc67 1 1 1 36h
replicaset.apps/kubefledged-webhook-server-597dbf4ff5 1 1 1 36h

Verifique a instalação bem-sucedida

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged]
└─$kubectl obter pods -n kube-fledged -l app=kubefledged
NOME PRONTO STATUS REINICIA IDADE
kubefledged-controller-55f848cc67-klxlm 1/1 Executando 0 16h
kubefledged-webhook-server-597dbf4ff5-ktbsh 1/1 Executando 0 16h
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged]
└─$kubectl obter imagecaches -n kube-fledged
Nenhum recurso encontrado no namespace desenvolvido pelo kube.

Usando kubefledged

Criar objeto de cache de imagem

Crie um objeto de cache de imagem com base no arquivo Demo 

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged]
└─$cd implantar/
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$cat kubefledged-imagecache.yaml
---
versão api: kubefledged.io/v1alpha2
tipo: ImageCache
metadados:
  # Nome do cache de imagens. Um cluster pode ter vários objetos de cache de imagem
  nome: imagecache1
  namespace: kube-fledged
  # O namespace kubernetes a ser usado para este cache de imagem. Você pode escolher um namespace diferente de acordo com sua preferência
  rótulos:
    aplicativo: kubefledged
    kubefledged: imagecache
especificação:
  # O campo "cacheSpec" permite que um usuário defina uma lista de imagens e em quais nós de trabalho essas imagens devem ser armazenadas em cache (ou seja, pré-extraídas).
  cacheSpec:
  # Especifica uma lista de imagens (nginx:1.23.1) sem seletor de nó, portanto, essas imagens serão armazenadas em cache em todos os nós do cluster
  - imagens:
    -ghcr.io/jitesoft/nginx:1.23.1
  # Especifica uma lista de imagens (cassandra:v7 e etcd:3.5.4-0) com um seletor de nó, portanto, essas imagens serão armazenadas em cache apenas nos nós selecionados pelo seletor de nó
  - imagens:
    -us.gcr.io/k8s-artifacts-prod/cassandra:v7
    -us.gcr.io/k8s-artifacts-prod/etcd:3.5.4-0
    seletor de nó:
      camada: back-end
  # Especifica uma lista de segredos de extração de imagens para extrair imagens de repositórios privados para o cache
  imagePullSecrets:
  -nome: minhachave de registro

A imagem correspondente na Demo oficial não pode ser retirada, então altere-a.

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$docker pull us.gcr.io/k8s-artifacts-prod/cassandra:v7
Resposta de erro do daemon: Obtenha "https://us.gcr.io/v2/": net/http: solicitação cancelada enquanto aguardava conexão (Client.Timeout excedido enquanto aguardava cabeçalhos)
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$

Para testar o uso de tags seletoras, encontramos a tag de um nó e fazemos o cache de imagens separadamente.

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$kubectl obter nós --show-labels

Ao mesmo tempo, extraímos a imagem diretamente do armazém público, portanto nenhum objeto é necessário imagePullSecrets 

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$vim kubefledged-imagecache.yaml

arquivo modificado yaml 

  • Adicionado um cache de imagem liruilong/my-busybox:latest para todos os nós
  • Adicionado um cache espelhado correspondente ao seletor de tags   kubernetes.io/hostname: vms105.liruilongs.github.io     liruilong/hikvision-sdk-config-ftp:latest  
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$cat kubefledged-imagecache.yaml
---
versão api: kubefledged.io/v1alpha2
tipo: ImageCache
metadados:
  # Nome do cache de imagens. Um cluster pode ter vários objetos de cache de imagem
  nome: imagecache1
  namespace: kube-fledged
  # O namespace kubernetes a ser usado para este cache de imagem. Você pode escolher um namespace diferente de acordo com sua preferência
  rótulos:
    aplicativo: kubefledged
    kubefledged: imagecache
especificação:
  # O campo "cacheSpec" permite que um usuário defina uma lista de imagens e em quais nós de trabalho essas imagens devem ser armazenadas em cache (ou seja, pré-extraídas).
  cacheSpec:
  # Especifica uma lista de imagens (nginx:1.23.1) sem seletor de nó, portanto, essas imagens serão armazenadas em cache em todos os nós do cluster
  - imagens:
    - liruilong/my-busybox:mais recente
  # Especifica uma lista de imagens (cassandra:v7 e etcd:3.5.4-0) com um seletor de nó, portanto, essas imagens serão armazenadas em cache apenas nos nós selecionados pelo seletor de nó
  - imagens:
    - liruilong/hikvision-sdk-config-ftp:mais recente
    seletor de nó:
      kubernetes.io/hostname: vms105.liruilongs.github.io
  # Especifica uma lista de segredos de extração de imagens para extrair imagens de repositórios privados para o cache
  #imagePullSegredos:
  #- nome: minhachave de registro
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$

Criado diretamente e relatou um erro

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$kubectl create -f kubefledged-imagecache.yaml
Erro do servidor (InternalError): erro ao criar "kubefledged-imagecache.yaml": Ocorreu um erro interno: falha ao chamar o webhook "validate-image-cache.kubefledged.io": falha ao chamar o webhook: Post "https://kubefledged- webhook-server.kube-fledged.svc:3443/validate-image-cache?timeout=1s": x509: certificado assinado por autoridade desconhecida (possivelmente devido a "crypto/rsa: erro de verificação" ao tentar verificar o certificado de autoridade candidata " kubefledged.io")
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$kubectl obter imagecaches -n kube-fledged
Nenhum recurso encontrado no namespace desenvolvido pelo kube.
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$

A solução é deletar o objeto correspondente e recriá-lo

Encontrei uma solução em um dos meus projetos atuais https://github.com/senthilrch/kube-fledged/issues/76 issues  

Parece que está codificado, mas quando o servidor é iniciado, um novo pacote CA é gerado e a configuração do webhook é atualizada. Quando ocorre outra implantação, o pacote CA original é reaplicado e as solicitações de webhook começam a falhar até que o componente webhook seja reiniciado novamente para corrigir o pacote init-server Webhook CA  webhook 

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged]
└─$make remove-kubefledged-and-operator
# Remover kubefledged
kubectl delete -f implantar/kubefledged-operator/deploy/crds/charts.helm.kubefledged.io_v1alpha2_kubefledged_cr.yaml
erro: mapeamento de recursos não encontrado para nome: namespace "kube-fledged": "kube-fledged" de "deploy/kubefledged-operator/deploy/crds/charts.helm.kubefledged.io_v1alpha2_kubefledged_cr.yaml": nenhuma correspondência para o tipo "KubeFledged "na versão"charts.helm.kubefledged.io/v1alpha2"
garantir que os CRDs sejam instalados primeiro
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged]
└─$make implantar usando yaml
kubectl apply -f implantar/kubefledged-namespace.yaml
namespace/kube-fledged criado
kubectl apply -f implantar/kubefledged-crd.yaml
customresourcedefinition.apiextensions.k8s.io/imagecaches.kubefledged.io inalterado
....................
implantação do status de implementação do kubectl kubefledged-webhook-server -n kube-fledged --watch
Aguardando a conclusão da implantação do "kubefledged-webhook-server": 0 de 1 réplicas atualizadas estão disponíveis...
implantação "kubefledged-webhook-server" lançada com sucesso
kubectl obter pods -n kube de pleno direito
NOME PRONTO STATUS REINICIA IDADE
kubefledged-controller-55f848cc67-76c4v 1/1 Executando 0 112s
kubefledged-webhook-server-597dbf4ff5-56h6z 1/1 Executando 0 66s

Recrie o objeto de cache e crie-o com sucesso

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$kubectl create -f kubefledged-imagecache.yaml
imagecache.kubefledged.io/imagecache1 criado
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$kubectl obter imagecaches -n kube-fledged
NOME IDADE
cache de imagem1 10s
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$

Ver o cache de imagens gerenciado atualmente

┌──[[email protected]]-[~/ansible/kube-fledged]
└─$kubectl obter imagecaches imagecache1 -n kube-fledged -o json
{
    "apiVersion": "kubefledged.io/v1alpha2",
    "kind": "ImageCache",
    "metadados": {
        "criaçãoTimestamp": "2024-03-01T15:08:42Z",
        "geração": 83,
        "rótulos": {
            "app": "kubefledged",
            "kubefledged": "imagecache"
        },
        "nome": "imagecache1",
        "namespace": "kube-fledged",
        "resourceVersion": "20169836",
        "uid": "3a680a57-d8ab-444f-b9c9-4382459c5c72"
    },
    "especificação": {
        "cacheSpec": [
            {
                "imagens": [
                    "liruilong/my-busybox:mais recente"
                ]
            },
            {
                "imagens": [
                    "liruilong/hikvision-sdk-config-ftp:mais recente"
                ],
                "nodeSeletor": {
                    "kubernetes.io/hostname": "vms105.liruilongs.github.io"
                }
            }
        ]
    },
    "status": {
        "completionTime": "2024-03-02T01:06:47Z",
        "message": "Todas as imagens solicitadas foram extraídas com sucesso para os respectivos nós",
        "motivo": "ImageCacheRefresh",
        "startTime": "2024-03-02T01:05:33Z",
        "status": "Sucesso"
    }
}
┌──[[email protected]]-[~/ansible/kube-fledged]
└─$

Verifique via ansible

┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/my-busybox" -i host.yaml
192.168.26.102 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.101 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.103 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.105 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.100 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.106 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
┌──[[email protected]]-[~/ansible]
└─$
┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/hikvision-sdk-config-ftp" -i host.yaml
192.168.26.102 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.100 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.103 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.105 | ALTERADO | rc = 0 >>
liruilong/hikvision-sdk-config-ftp mais recente a02cd03b4342 4 meses atrás 830 MB
192.168.26.101 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.106 | FALHA | rc = 1 >>
código de retorno diferente de zero
┌──[[email protected]]-[~/ansible]
└─$

Ative a atualização automática

┌──[[email protected]]-[~/ansible]
└─$kubectl anotar imagecaches imagecache1 -n kube desenvolvido kubefledged.io/refresh-imagecache=
imagecache.kubefledged.io/imagecache1 anotado
┌──[[email protected]]-[~/ansible]
└─$

Adicionar cache de imagens

Adicione um novo cache de imagem

┌──[[email protected]]-[~/ansible]
└─$kubectl obter imagecaches.kubefledged.io -n imagecache1 kube -o json
{
    "apiVersion": "kubefledged.io/v1alpha2",
    "kind": "ImageCache",
    "metadados": {
        "criaçãoTimestamp": "2024-03-01T15:08:42Z",
        "geração": 92,
        "rótulos": {
            "app": "kubefledged",
            "kubefledged": "imagecache"
        },
        "nome": "imagecache1",
        "namespace": "kube-fledged",
        "resourceVersion": "20175233",
        "uid": "3a680a57-d8ab-444f-b9c9-4382459c5c72"
    },
    "especificação": {
        "cacheSpec": [
            {
                "imagens": [
                    "liruilong/my-busybox:mais recente",
                    "liruilong/jdk1.8_191:mais recente"
                ]
            },
            {
                "imagens": [
                    "liruilong/hikvision-sdk-config-ftp:mais recente"
                ],
                "nodeSeletor": {
                    "kubernetes.io/hostname": "vms105.liruilongs.github.io"
                }
            }
        ]
    },
    "status": {
        "completionTime": "2024-03-02T01:43:32Z",
        "message": "Todas as imagens solicitadas foram extraídas com sucesso para os respectivos nós",
        "motivo": "ImageCacheUpdate",
        "startTime": "2024-03-02T01:40:34Z",
        "status": "Sucesso"
    }
}
┌──[[email protected]]-[~/ansible]
└─$

Confirmar via ansible

┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/jdk1.8_191" -i host.yaml
192.168.26.101 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.100 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.102 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.103 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.105 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.106 | FALHA | rc = 1 >>
código de retorno diferente de zero
┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/jdk1.8_191" -i host.yaml
192.168.26.101 | ALTERADO | rc = 0 >>
liruilong/jdk1.8_191 mais recente 17dbd4002a8c 5 anos atrás 170 MB
192.168.26.102 | ALTERADO | rc = 0 >>
liruilong/jdk1.8_191 mais recente 17dbd4002a8c 5 anos atrás 170 MB
192.168.26.100 | ALTERADO | rc = 0 >>
liruilong/jdk1.8_191 mais recente 17dbd4002a8c 5 anos atrás 170 MB
192.168.26.103 | ALTERADO | rc = 0 >>
liruilong/jdk1.8_191 mais recente 17dbd4002a8c 5 anos atrás 170 MB
192.168.26.105 | ALTERADO | rc = 0 >>
liruilong/jdk1.8_191 mais recente 17dbd4002a8c 5 anos atrás 170 MB
192.168.26.106 | ALTERADO | rc = 0 >>
liruilong/jdk1.8_191 mais recente 17dbd4002a8c 5 anos atrás 170 MB
┌──[[email protected]]-[~/ansible]
└─$

Excluir cache de imagens

┌──[[email protected]]-[~/ansible]
└─$kubectl editar imagecaches imagecache1 -n kube-fledged
imagecache.kubefledged.io/imagecache1 editado
┌──[[email protected]]-[~/ansible]
└─$kubectl obter imagecaches.kubefledged.io -n imagecache1 kube -o json
{
    "apiVersion": "kubefledged.io/v1alpha2",
    "kind": "ImageCache",
    "metadados": {
        "criaçãoTimestamp": "2024-03-01T15:08:42Z",
        "geração": 94,
        "rótulos": {
            "app": "kubefledged",
            "kubefledged": "imagecache"
        },
        "nome": "imagecache1",
        "namespace": "kube-fledged",
        "resourceVersion": "20175766",
        "uid": "3a680a57-d8ab-444f-b9c9-4382459c5c72"
    },
    "especificação": {
        "cacheSpec": [
            {
                "imagens": [
                    "liruilong/jdk1.8_191:mais recente"
                ]
            },
            {
                "imagens": [
                    "liruilong/hikvision-sdk-config-ftp:mais recente"
                ],
                "nodeSeletor": {
                    "kubernetes.io/hostname": "vms105.liruilongs.github.io"
                }
            }
        ]
    },
    "status": {
        "message": "O cache de imagens está sendo atualizado. Por favor, veja o status depois de algum tempo",
        "motivo": "ImageCacheUpdate",
        "startTime": "2024-03-02T01:48:03Z",
        "status": "Processando"
    }
}

Através da confirmação do Ansible, você pode ver que, seja o nó master ou o nó de trabalho, o cache de imagem correspondente foi limpo.

┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/my-busybox" -i host.yaml
192.168.26.102 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.101 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.105 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.100 | ALTERADO | rc = 0 >>
liruilong/my-busybox mais recente 497b83a63aad 11 meses atrás 1,24 MB
192.168.26.103 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.106 | FALHA | rc = 1 >>
código de retorno diferente de zero
┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/my-busybox" -i host.yaml
192.168.26.105 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.102 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.103 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.101 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.100 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.106 | FALHA | rc = 1 >>
código de retorno diferente de zero
┌──[[email protected]]-[~/ansible]
└─$

Deve-se notar aqui que se todos os caches de imagem forem limpos, o seguinte array precisa ser escrito como "". images 

┌──[[email protected]]-[~/ansible]
└─$kubectl editar imagecaches imagecache1 -n kube-fledged
imagecache.kubefledged.io/imagecache1 editado
┌──[[email protected]]-[~/ansible]
└─$ansible all -m shell -a "docker images | grep liruilong/jdk1.8_191" -i host.yaml
192.168.26.102 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.101 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.100 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.105 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.103 | FALHA | rc = 1 >>
código de retorno diferente de zero
192.168.26.106 | FALHA | rc = 1 >>
código de retorno diferente de zero
┌──[[email protected]]-[~/ansible]
└─$kubectl obter imagecaches.kubefledged.io -n imagecache1 kube -o json
{
    "apiVersion": "kubefledged.io/v1alpha2",
    "kind": "ImageCache",
    "metadados": {
        "criaçãoTimestamp": "2024-03-01T15:08:42Z",
        "geração": 98,
        "rótulos": {
            "app": "kubefledged",
            "kubefledged": "imagecache"
        },
        "nome": "imagecache1",
        "namespace": "kube-fledged",
        "resourceVersion": "20176849",
        "uid": "3a680a57-d8ab-444f-b9c9-4382459c5c72"
    },
    "especificação": {
        "cacheSpec": [
            {
                "imagens": [
                    ""
                ]
            },
            {
                "imagens": [
                    "liruilong/hikvision-sdk-config-ftp:mais recente"
                ],
                "nodeSeletor": {
                    "kubernetes.io/hostname": "vms105.liruilongs.github.io"
                }
            }
        ]
    },
    "status": {
        "completionTime": "2024-03-02T01:52:16Z",
        "message": "Todas as imagens em cache foram excluídas com sucesso dos respectivos nós",
        "motivo": "ImageCacheUpdate",
        "startTime": "2024-03-02T01:51:47Z",
        "status": "Sucesso"
    }
}
┌──[[email protected]]-[~/ansible]
└─$

Se excluído pelo método a seguir, comente diretamente a tag correspondente

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$cat kubefledged-imagecache.yaml
---
versão api: kubefledged.io/v1alpha2
tipo: ImageCache
metadados:
  # Nome do cache de imagens. Um cluster pode ter vários objetos de cache de imagem
  nome: imagecache1
  namespace: kube-fledged
  # O namespace kubernetes a ser usado para este cache de imagem. Você pode escolher um namespace diferente de acordo com sua preferência
  rótulos:
    aplicativo: kubefledged
    kubefledged: imagecache
especificação:
  # O campo "cacheSpec" permite que um usuário defina uma lista de imagens e em quais nós de trabalho essas imagens devem ser armazenadas em cache (ou seja, pré-extraídas).
  cacheSpec:
  # Especifica uma lista de imagens (nginx:1.23.1) sem seletor de nó, portanto, essas imagens serão armazenadas em cache em todos os nós do cluster
  #- imagens:
    #- liruilong/my-busybox:mais recente
  # Especifica uma lista de imagens (cassandra:v7 e etcd:3.5.4-0) com um seletor de nó, portanto, essas imagens serão armazenadas em cache apenas nos nós selecionados pelo seletor de nó
  - imagens:
    - liruilong/hikvision-sdk-config-ftp:mais recente
    seletor de nó:
      kubernetes.io/hostname: vms105.liruilongs.github.io
  # Especifica uma lista de segredos de extração de imagens para extrair imagens de repositórios privados para o cache
  #imagePullSegredos:
  #- nome: minhachave de registro
┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$

Então o seguinte erro será relatado

┌──[[email protected]]-[~/ansible/kube-fledged/kube-fledged/deploy]
└─$kubectl editar imagecaches imagecache1 -n kube-fledged
erro: imagecaches.kubefledged.io "imagecache1" não pôde ser corrigido: webhook de admissão "validate-image-cache.kubefledged.io" negou a solicitação: incompatibilidade no no. de listas de imagens
Você pode executar `kubectl replace -f /tmp/kubectl-edit-4113815075.yaml` para tentar esta atualização novamente.

Referência a parte da postagem do blog

© Os direitos autorais dos links de referência neste artigo pertencem ao autor original. Se houver alguma violação, informe-nos. Se você concorda com isso, não seja mesquinho com as estrelas :)

https://github.com/senthilrch/kube-fledged

 

Clique para seguir e conhecer as novas tecnologias da Huawei Cloud o mais rápido possível~

 

Companheiro de frango, deepin-IDE de "código aberto" e finalmente conseguiu a inicialização! Bom cara, a Tencent realmente transformou o Switch em uma "máquina de aprendizagem pensante" Revisão de falhas e explicação da situação da Tencent Cloud em 8 de abril Reconstrução de inicialização de desktop remoto RustDesk Cliente Web Banco de dados de terminal de código aberto do WeChat baseado em SQLite WCDB inaugurou uma grande atualização Lista de abril TIOBE: PHP caiu para o nível mais baixo, Fabrice Bellard, o pai do FFmpeg, lançou a ferramenta de compressão de áudio TSAC , o Google lançou um grande modelo de código, CodeGemma , isso vai te matar? É tão bom que é de código aberto - ferramenta de edição de imagens e pôsteres de código aberto
{{o.nome}}
{{m.nome}}

Acho que você gosta

Origin my.oschina.net/u/4526289/blog/11052468
Recomendado
Clasificación