Homepage pessoal: Conquering bugs-CSDN blog
coluna kubernetes: kubernetes_Conquering bug blog-CSDN blog
Índice
3 pods executando vários contêineres
1 O que é um pod
Extraia o site oficial: Pod | Kubernetes
1.1 Introdução
Um pod é a menor unidade implantável de computação que pode ser criada e gerenciada no Kubernetes . Um Pod (como em Whale Pods ou Pea Pods) é um grupo (um ou mais) de contêineres ; esses contêineres compartilham armazenamento, rede e uma declaração de como executar esses contêineres. O conteúdo em um pod é sempre colocado e agendado junto, sendo executado em um contexto compartilhado . Resumindo, se descrito nos termos do Docker, um Pod é semelhante a um grupo de contêineres que compartilham um namespace e um volume de sistema de arquivos.
定义: Pod 就是用来管理一组(一个|多个)容器的集合 特点: 共享网络 共享存储 共享上下文环境
1.2 Como o Pod gerencia vários contêineres?
Os contêineres em um pod são agendados automaticamente na mesma máquina física ou virtual no cluster e podem ser agendados juntos. Os contêineres podem compartilhar recursos e dependências, comunicar-se entre si e coordenar quando e como encerrar a si mesmos. Por exemplo, você pode ter um contêiner que fornece suporte de servidor da Web para arquivos em um volume compartilhado e um contêiner "sidercar" separado que atualiza esses arquivos remotamente, conforme mostrado no diagrama a seguir:
1.3 Como usar os pods?
Normalmente, você não precisa criar pods diretamente, nem mesmo pods de instância única. Em vez disso, você cria pods usando recursos de carga de trabalho, como implantações ou jobs. Se os pods precisarem rastrear o estado, considere os recursos StatefulSet.
Existem dois usos principais de pods em um cluster Kubernetes:
-
Um pod que executa um único contêiner . O modelo "um contêiner por pod" é o caso de uso mais comum do Kubernetes; nesse caso, um pod pode ser pensado como um wrapper em torno de um único contêiner, e o Kubernetes gerencia os pods diretamente, não os contêineres.
-
Pods que executam vários contêineres trabalhando juntos . Um pod pode encapsular um aplicativo que consiste em vários contêineres co-localizados que são fortemente acoplados e precisam compartilhar recursos. Esses contêineres co-localizados podem formar uma única unidade de serviço coesa - um contêiner que serve arquivos de um volume compartilhado para o público, enquanto um contêiner "secundário" separado atualiza ou atualiza esses arquivos. Os pods empacotam esses contêineres e recursos de armazenamento em uma entidade gerenciável.
ilustrar:
-
Organizar vários contêineres colocados e cogerenciados em um pod é um caso de uso relativamente avançado. Você só deve usar esse padrão em cenários em que os contêineres estão intimamente relacionados.
-
Cada Pod é projetado para executar uma única instância de um determinado aplicativo. Se você deseja dimensionar seu aplicativo horizontalmente (por exemplo, executar várias instâncias para fornecer mais recursos), use vários pods, um para cada instância. No Kubernetes, isso geralmente é chamado de cópia (replicação) . Normalmente, um recurso de carga de trabalho e seu controlador são usados para criar e gerenciar um conjunto de réplicas de pod.
Operação básica de 2 cápsulas
2.1 Exibir pods
# 查看默认命名空间的 pod
$ kubectl get pods|pod|po
# 查看所有命名空间的 pod
$ kubectl get pods|pod -A
$ kubectl get pods|pod|po -n 命名空间名称
# 查看默认命名空间下 pod 的详细信息
$ kubectl get pods -o wide
# 查看所有命名空间下 pod 的详细信息
$ kubectl get pods -o wide -A
# 实时监控 pod 的状态
$ kubectl get pod -w2.2 Criar pods
pod: kubectl run nginx (nome do pod) --image=nginx:1.19
container: docker run --name nginx nginx:1.19
Endereço de referência do site oficial: Pod | Kubernetes
# nginx-pod.yml
apiVersion: v1
kind: Pod
metadata:
name: nginx
spec:
containers:
- name: nginx
image: nginx:1.19
ports:
- containerPort: 80
# 使用 kubectl apply/create -f 创建 pod
$ kubectl create -f nginx-pod.yml
$ kubectl apply -f nginx-pod.yml
注意: create 仅仅是不存在时创建,如果已经存在则报错！apply 不存在创建，存在更新配置。推荐使用 apply！
2.3 Excluir pods
$ kubectl delete pod pod名称
$ kubectl delete -f pod.yml2.4 Insira o recipiente no pod
# 注意: 这种方式进入容器默认只会进入 pod 中第一个容器
$ kubectl exec -it nginx(pod名称) --(固定写死) bash(执行命令)
# 注意: 进入指定 pod 中指定容器
$ kubectl exec -it pod名称 -c 容器名称 --(固定写死) bash(执行命令)2.5 Exibir logs do pod
# 注意: 查看 pod 中第一个容器日志
$ kubectl logs -f(可选,实时) nginx(pod 名称)
# 注意: 查看 pod 中指定容器的日志
$ kubect logs -f pod名称 -c 容器名称2.6 Exibir informações de descrição do pod
$ kubectl describe pod nginx(pod名称)3 pods executando vários contêineres
3.1 Criar pods
# myapp-pod.yml
apiVersion: v1
kind: Pod
metadata:
name: myapp
spec:
containers:
- name: nginx
image: nginx:1.19
ports:
- containerPort: 80
imagePullPolicy: IfNotPresent
- name: redis
image: redis:5.0.10
ports:
- containerPort: 6379
imagePullPolicy: IfNotPresent
criar corrida
$ kubectl apply -f myapp-pod.yml3.2 Exibir o log do contêiner especificado
# 查看日志 (默认只查看第一个容器日志，这里是展示 nginx 日志)
$ kubectl logs -f myapp
# 查看 pod 中指定容器的日志
$ kubectl logs -f myapp -c nginx(容器名称)
$ kubectl logs -f myapp -c redis(容器名称)3.3 Acesso ao contêiner
# 进入 pod 的容器 (默认进入第一个容器内部，这里会进入 nginx 容器内部)
$ kubectl exec -it myapp -- sh
# 进入 pod 中指定容器内部
$ kubectl exec -it myapp -c nginx -- sh
$ kubectl exec -it myapp -c redis -- sh4 rótulos de pods (rótulos)
标签（Labels）são pares chave-valor anexados a objetos do Kubernetes, como pods. Os rótulos devem ser usados para especificar propriedades de identificação de objetos que são significativos e relevantes para o usuário. Os rótulos podem ser anexados aos objetos no momento da criação e, posteriormente, podem ser adicionados e modificados a qualquer momento. Cada objeto pode definir um conjunto de rótulos de chave/valor, mas cada chave deve ser exclusiva para um determinado objeto.
Função Label: É usado para alias os objetos em k8s, e com o alias, você pode filtrar e filtrar
4.1 Gramática
标签由键值对组成, cujos valores de tag válidos são:
-
Deve ter 63 caracteres ou menos (pode estar vazio)
-
[a-z0-9A-Z]Deve começar e terminar com um caractere alfanumérico ( ), a menos que o valor da tag esteja vazio -
Contém traços (
-), sublinhados (_), pontos (.) e letras ou números
4.2 Exemplos
apiVersion: v1
kind: Pod
metadata:
name: myapp
labels:
name: myapp #创建时添加
spec:
containers:
- name: nginx
image: nginx:1.21
imagePullPolicy: IfNotPresent
- name: redis
image: redis:5.0.10
imagePullPolicy: IfNotPresent
restartPolicy: Always4.3 Operações básicas de etiquetas
# 查看标签
$ kubectl get pods --show-labels
# kubectl label pod pod名称 标签键值对
$ kubectl label pod myapp env=prod
# 覆盖标签 --overwrite
$ kubectl label --overwrite pod myapp env=test
# 删除标签 -号代表删除标签
$ kubectl label pod myapp env-
# 根据标签筛选 env=test/env > = <
$ kubectl get po -l env=test
$ kubectl get po -l env
$ kubectl get po -l '!env' # 不包含的 pod
$ kubectl get po -l 'env in (test,prod)' #选择含有指定值的 pod
$ kubectl get po -l 'env notin (test,prod)' #选择含有指定值的 pod5 ciclo de vida do pod
Extraído do site oficial: Ciclo de vida do pod | Kubernetes
Os pods seguem um ciclo de vida predefinido, começando no Pendingestágio , entrando se pelo menos um dos contêineres primários começou normalmente e, em seguida, entrando ou estágio Running, dependendo se algum contêiner no pod terminou em um estado de falha . Ao mesmo tempo, o Pod será agendado apenas uma vez durante sua vida útil. Depois que um pod é agendado (atribuído) a um nó, ele será executado nesse nó até que seja interrompido ou encerrado.SucceededFailed
5.1 Ciclo de vida
Assim como contêineres de aplicativos individuais, os pods são considerados entidades relativamente efêmeras (em vez de de longa duração). Os pods são criados, recebem um ID exclusivo (UID) e agendados para um nó, onde são executados até serem encerrados (de acordo com a política de reinicialização) ou excluídos. Se um nó morrer, os pods programados para esse nó também serão programados para exclusão após o término do período de tempo limite especificado.
Os próprios pods não têm recursos de autocorreção. Se um Pod estiver programado para um nó e o nó falhar posteriormente, o Pod será excluído; da mesma forma, um Pod não pode sobreviver ao ser removido devido ao esgotamento dos recursos do nó ou à manutenção do nó. O Kubernetes usa uma abstração de alto nível para gerenciar essas instâncias de pod relativamente descartáveis, chamadas de controlador.
Qualquer Pod fornecido (definido por UID) nunca é "reagendado" para um nó diferente; em vez disso, o Pod pode ser substituído por um novo Pod quase idêntico. O novo Pod pode ter o mesmo nome, se desejado, mas seu UID será diferente.
Se algo afirma ter o mesmo tempo de vida de um Pod, como um volume de armazenamento, isso significa que o objeto vive enquanto o Pod (que também tem o mesmo UID) existir. Se um Pod for excluído por qualquer motivo, mesmo quando um Pod de substituição idêntico for criado, os objetos relacionados (como volumes aqui) também serão excluídos e recriados.
5.2 estágios de pod
O número e o significado dos estágios do Pod são estritamente definidos. Não se deve presumir que os pods tenham valores diferentes dos listados neste documento phase.
| valor | descrever |
|---|---|
Pending(pendente) |
O pod foi aceito pelo sistema Kubernetes, mas um ou mais contêineres ainda não foram criados e não estão em execução. Esta fase inclui o tempo de espera para o agendamento do Pod e o tempo necessário para baixar a imagem pela rede. |
Running(correndo) |
O pod foi vinculado a um nó e todos os contêineres no pod foram criados. Pelo menos um contêiner ainda está em execução ou no processo de inicialização ou reinicialização. |
Succeeded(sucesso) |
Todos os contêineres no pod foram encerrados com sucesso e não serão reiniciados. |
Failed(falhar) |
Todos os contêineres no pod foram encerrados e pelo menos um contêiner encerrado devido a uma falha. Ou seja, o contêiner saiu com um status diferente de zero ou foi encerrado pelo sistema. |
Unknown(desconhecido) |
Não foi possível obter o status do pod por algum motivo. Isso geralmente ocorre porque a comunicação com o host em que o pod reside falhou. |
ilustrar:
Quando um pod é excluído, a execução de alguns comandos kubectl mostrará o status do pod como
Terminating(encerrado). EsseTerminatingestado não é um dos estágios do pod. Os pods recebem um prazo para encerrar normalmente, cujo padrão é 30 segundos. Você pode usar--forceo parâmetro para encerrar o pod à força.Se um nó morrer ou perder contato com outros nós no cluster, o Kubernetes aplicará uma política que define os s de todos os pods em execução no nó perdido
phasecomoFailed.