# Table of Contents
- [Overview | Kubernetes](#overview-kubernetes)
- [Instalasi Add-ons | Kubernetes](#instalasi-add-ons-kubernetes)
- [安装扩展(Addon) | Kubernetes](#-addon-kubernetes)
- [使用 kubeconfig 文件组织集群访问 | Kubernetes](#-kubeconfig-kubernetes)
- [Kubernetes | Kubernetes](#kubernetes-kubernetes)
- [アドオンのインストール | Kubernetes](#-kubernetes)
- [kubeconfigファイルを使用してクラスターアクセスを組織する | Kubernetes](#kubeconfig-kubernetes)
- [애드온 설치 | Kubernetes](#-kubernetes)
- [kubeconfig 파일을 사용하여 클러스터 접근 구성하기 | Kubernetes](#kubeconfig-kubernetes)
- [Configurazione | Kubernetes](#configurazione-kubernetes)
- [Instalando Complementos | Kubernetes](#instalando-complementos-kubernetes)
- [Organizando o acesso ao cluster usando arquivos kubeconfig | Kubernetes](#organizando-o-acesso-ao-cluster-usando-arquivos-kubeconfig-kubernetes)
- [Architettura di Kubernetes | Kubernetes](#architettura-di-kubernetes-kubernetes)
- [Containers | Kubernetes](#containers-kubernetes)
- [Documentazione di Kubernetes | Kubernetes](#documentazione-di-kubernetes-kubernetes)
- [Tutorials | Kubernetes](#tutorials-kubernetes)
- [Manage Cluster Daemons | Kubernetes](#manage-cluster-daemons-kubernetes)
- [नीतियाँ | Kubernetes](#-kubernetes)
- [Other Tools | Kubernetes](#other-tools-kubernetes)
- [उत्पादन वातावरण | Kubernetes](#-kubernetes)
- [शुरू करना | Kubernetes](#-kubernetes)
- [Networking | Kubernetes](#networking-kubernetes)
- [Concetti | Kubernetes](#concetti-kubernetes)
- [Przechowywanie danych | Kubernetes](#przechowywanie-danych-kubernetes)
- [Kubernetes Documentation | Kubernetes](#kubernetes-documentation-kubernetes)
- [कुबेरनेट्स प्रलेखन | Kubernetes](#-kubernetes)
- [Kubernetes Dokumentation | Kubernetes](#kubernetes-dokumentation-kubernetes)
- [उत्तम प्रथाएं | Kubernetes](#-kubernetes)
- [Administrasi Klaster | Kubernetes](#administrasi-klaster-kubernetes)
- [Konfiguracja | Kubernetes](#konfiguracja-kubernetes)
- [Amministrazione del Cluster | Kubernetes](#amministrazione-del-cluster-kubernetes)
- [Kubernetes — Dokumentacja | Kubernetes](#kubernetes-dokumentacja-kubernetes)
- [TLS | Kubernetes](#tls-kubernetes)
- [Kubectl Reference Docs](#kubectl-reference-docs)
- [Polityki | Kubernetes](#polityki-kubernetes)
- [कुबेरनेटेस डॉक्स में योगदान दे | Kubernetes](#-kubernetes)
- [Styl dokumentacji | Kubernetes](#styl-dokumentacji-kubernetes)
- [Documentazione | Kubernetes](#documentazione-kubernetes)
- [शेडुलिंग | Kubernetes](#-kubernetes)
- [Współtworzenie nowych treści | Kubernetes](#wsp-tworzenie-nowych-tre-ci-kubernetes)
- [उपकरण स्थापित करें | Kubernetes](#-kubernetes)
- [404 Page not found | Kubernetes](#404-page-not-found-kubernetes)
- [Kontenery | Kubernetes](#kontenery-kubernetes)
- [Aktualizacja materiałów źródłowych | Kubernetes](#aktualizacja-materia-w-r-d-owych-kubernetes)
- [अन्य उपकरण | Kubernetes](#-kubernetes)
- [Pojęcia | Kubernetes](#poj-cia-kubernetes)
- [Event Rate Limit Configuration (v1alpha1) | Kubernetes](#event-rate-limit-configuration-v1alpha1-kubernetes)
- [IPv4/IPv6 双协议栈 | Kubernetes](#ipv4-ipv6-kubernetes)
- [生产环境 | Kubernetes](#-kubernetes)
- [Kubernetes 问题和安全 | Kubernetes](#kubernetes-kubernetes)
- [부트스트랩 토큰을 사용한 인증 | Kubernetes](#-kubernetes)
- [Kubernetes 安全和信息披露 | Kubernetes](#kubernetes-kubernetes)
- [Kubelet CredentialProvider (v1) | Kubernetes](#kubelet-credentialprovider-v1-kubernetes)
- [Установка дополнений | Kubernetes](#-kubernetes)
- [Kubernetes Secret 良好实践 | Kubernetes](#kubernetes-secret-kubernetes)
- [CSI 卷克隆 | Kubernetes](#csi-kubernetes)
- [外部 API | Kubernetes](#-api-kubernetes)
- [Storage | Kubernetes](#storage-kubernetes)
- [Linux 节点的交换(Swap)行为 | Kubernetes](#linux-swap-kubernetes)
- [由 kubelet 填充的节点标签 | Kubernetes](#-kubelet-kubernetes)
- [Ikhtisar | Kubernetes](#ikhtisar-kubernetes)
- [Memberlakukan Standar Keamanan Pod | Kubernetes](#memberlakukan-standar-keamanan-pod-kubernetes)
- [调试集群 | Kubernetes](#-kubernetes)
- [运行于多可用区环境 | Kubernetes](#-kubernetes)
- [Официальный CVE-фид | Kubernetes](#-cve-kubernetes)
- [Utilizando Autorização ABAC | Kubernetes](#utilizando-autoriza-o-abac-kubernetes)
- [kube-apiserver Audit 配置(v1) | Kubernetes](#kube-apiserver-audit-v1-kubernetes)
- [কুবারনেটিসে অবদান | Kubernetes](#-kubernetes)
- [Unterstützte Versionen der Kubernetes-Dokumentation | Kubernetes](#unterst-tzte-versionen-der-kubernetes-dokumentation-kubernetes)
- [kubelet 所使用的本地文件和路径 | Kubernetes](#kubelet-kubernetes)
- [PKI証明書とその要件 | Kubernetes](#pki-kubernetes)
- [组件工具 | Kubernetes](#-kubernetes)
- [工作负载 | Kubernetes](#-kubernetes)
- [Windows 存储 | Kubernetes](#windows-kubernetes)
- [工作负载管理 | Kubernetes](#-kubernetes)
- [Visão Geral de Autorização | Kubernetes](#vis-o-geral-de-autoriza-o-kubernetes)
- [Services, Load Balancing, dan Jaringan | Kubernetes](#services-load-balancing-dan-jaringan-kubernetes)
- [서비스가 지원하는 프로토콜 | Kubernetes](#-kubernetes)
- [Connecting Applications with Services | Kubernetes](#connecting-applications-with-services-kubernetes)
- [VolumeSnapshotClass | Kubernetes](#volumesnapshotclass-kubernetes)
- [进程 ID 约束与预留 | Kubernetes](#-id-kubernetes)
- [Keamanan | Kubernetes](#keamanan-kubernetes)
- [Addons Installieren | Kubernetes](#addons-installieren-kubernetes)
- [Supervisión del Estado del Volumen | Kubernetes](#supervisi-n-del-estado-del-volumen-kubernetes)
- [Berpartisipasi dalam SIG Docs | Kubernetes](#berpartisipasi-dalam-sig-docs-kubernetes)
- [客户端身份认证(Client Authentication)(v1beta1) | Kubernetes](#-client-authentication-v1beta1-kubernetes)
- [kubelet systemd 看门狗 | Kubernetes](#kubelet-systemd-kubernetes)
- [Pod 安全性准入 | Kubernetes](#pod-kubernetes)
- [Pods | Kubernetes](#pods-kubernetes)
- [Arsitektur Kubernetes | Kubernetes](#arsitektur-kubernetes-kubernetes)
- [Resourcen-Verwaltung für Pods und Container | Kubernetes](#resourcen-verwaltung-f-r-pods-und-container-kubernetes)
- [Windows 节点的安全性 | Kubernetes](#windows-kubernetes)
- [Acceder al clúster y las aplicaciones | Kubernetes](#acceder-al-cl-ster-y-las-aplicaciones-kubernetes)
- [Pertimbangan untuk klaster besar | Kubernetes](#pertimbangan-untuk-klaster-besar-kubernetes)
- [Image Policy API (v1alpha1) | Kubernetes](#image-policy-api-v1alpha1-kubernetes)
- [容器 | Kubernetes](#-kubernetes)
- [노드 레퍼런스 정보 | Kubernetes](#-kubernetes)
- [Imagens | Kubernetes](#imagens-kubernetes)
- [네트워킹 레퍼런스 | Kubernetes](#-kubernetes)
- [Persistent Volume | Kubernetes](#persistent-volume-kubernetes)
- [Kubernetes 自定义指标 (v1beta2) | Kubernetes](#kubernetes-v1beta2-kubernetes)
- [自动扩缩工作负载 | Kubernetes](#-kubernetes)
- [Comunicação entre Nós e a Camada de Gerenciamento | Kubernetes](#comunica-o-entre-n-s-e-a-camada-de-gerenciamento-kubernetes)
- [Tài liệu tham khảo | Kubernetes](#t-i-li-u-tham-kh-o-kubernetes)
- [Podセキュリティ標準の強制 | Kubernetes](#pod-kubernetes)
- [Instalación de Complementos (AddOns) | Kubernetes](#instalaci-n-de-complementos-addons-kubernetes)
- [提出内容改进建议 | Kubernetes](#-kubernetes)
- [容器环境 | Kubernetes](#-kubernetes)
- [Service 与 Pod 的 DNS | Kubernetes](#service-pod-dns-kubernetes)
- [NetworkPolicy | Kubernetes](#networkpolicy-kubernetes)
- [Ingress 控制器 | Kubernetes](#ingress-kubernetes)
- [安装工具 | Kubernetes](#-kubernetes)
- [Kubernetes z-pages | Kubernetes](#kubernetes-z-pages-kubernetes)
- [kubelet 配置 (v1alpha1) | Kubernetes](#kubelet-v1alpha1-kubernetes)
- [Überblick | Kubernetes](#-berblick-kubernetes)
- [Kubernetes Architektur | Kubernetes](#kubernetes-architektur-kubernetes)
- [Workloads | Kubernetes](#workloads-kubernetes)
- [混合版本代理 | Kubernetes](#-kubernetes)
- [端口和协议 | Kubernetes](#-kubernetes)
- [Runtime Container | Kubernetes](#runtime-container-kubernetes)
- [KYAML 参考 | Kubernetes](#kyaml-kubernetes)
- [云原生安全和 Kubernetes | Kubernetes](#-kubernetes-kubernetes)
- [大規模クラスターの構築 | Kubernetes](#-kubernetes)
- [Über cgroup v2 | Kubernetes](#-ber-cgroup-v2-kubernetes)
- [Pod 安全策略 | Kubernetes](#pod-kubernetes)
- [Ferramentas de Configuração | Kubernetes](#ferramentas-de-configura-o-kubernetes)
- [网络策略 | Kubernetes](#-kubernetes)
- [Speicher | Kubernetes](#speicher-kubernetes)
- [Ingress | Kubernetes](#ingress-kubernetes)
- [ノードのセットアップの検証 | Kubernetes](#-kubernetes)
- [Сборщик мусора | Kubernetes](#-kubernetes)
- [ওভারভিউ | Kubernetes](#-kubernetes)
- [容器运行时 | Kubernetes](#-kubernetes)
- [ネットワーキングのリファレンス | Kubernetes](#-kubernetes)
- [콘텐츠 개선 제안하기 | Kubernetes](#-kubernetes)
- [Coleta de Lixo | Kubernetes](#coleta-de-lixo-kubernetes)
- [存储 | Kubernetes](#-kubernetes)
- [动态卷制备 | Kubernetes](#-kubernetes)
- [Unknown](#unknown)
- [Turnkey 云解决方案 | Kubernetes](#turnkey-kubernetes)
- [使用部署工具安装 Kubernetes | Kubernetes](#-kubernetes-kubernetes)
- [配置 | Kubernetes](#-kubernetes)
- [Pengklonaan Volume CSI | Kubernetes](#pengklonaan-volume-csi-kubernetes)
- [Service | Kubernetes](#service-kubernetes)
- [Alokasi ClusterIP pada servis (Service ClusterIP allocation) | Kubernetes](#alokasi-clusterip-pada-servis-service-clusterip-allocation-kubernetes)
- [Visão Geral da Segurança Cloud Native | Kubernetes](#vis-o-geral-da-seguran-a-cloud-native-kubernetes)
- [参与 SIG Docs | Kubernetes](#-sig-docs-kubernetes)
- [Kubernetes 指标 (v1beta1) | Kubernetes](#kubernetes-v1beta1-kubernetes)
- [官方 CVE 订阅源 | Kubernetes](#-cve-kubernetes)
- [プロダクション環境 | Kubernetes](#-kubernetes)
- [Persiapan | Kubernetes](#persiapan-kubernetes)
- [Secrets | Kubernetes](#secrets-kubernetes)
- [Ingress | Kubernetes](#ingress-kubernetes)
- [Versi Dokumentasi yang Tersedia | Kubernetes](#versi-dokumentasi-yang-tersedia-kubernetes)
- [도커심 제거 및 CRI 호환 런타임 사용에 대한 기사 | Kubernetes](#-cri-kubernetes)
- [存活、就绪和启动探针 | Kubernetes](#-kubernetes)
- [KubeletチェックポイントAPI | Kubernetes](#kubelet-api-kubernetes)
- [Best practices | Kubernetes](#best-practices-kubernetes)
- [Service 所用的协议 | Kubernetes](#service-kubernetes)
- [IPv4/IPv6 dual-stack | Kubernetes](#ipv4-ipv6-dual-stack-kubernetes)
- [Problèmes et alertes de sécurité de Kubernetes | Kubernetes](#probl-mes-et-alertes-de-s-curit-de-kubernetes-kubernetes)
- [Kontainer Environment | Kubernetes](#kontainer-environment-kubernetes)
- [DNS untuk Service dan Pod | Kubernetes](#dns-untuk-service-dan-pod-kubernetes)
- [Überwachung, Protokollierung und Fehlerbehebung | Kubernetes](#-berwachung-protokollierung-und-fehlerbehebung-kubernetes)
- [Visão Geral | Kubernetes](#vis-o-geral-kubernetes)
- [卷 | Kubernetes](#-kubernetes)
- [Referencia | Kubernetes](#referencia-kubernetes)
- [Formación en línea | Kubernetes](#formaci-n-en-l-nea-kubernetes)
- [Kubernetes Vulnerability Announcements - CVE Feed](#kubernetes-vulnerability-announcements-cve-feed)
- [外部 API | Kubernetes](#-api-kubernetes)
- [Gateway API | Kubernetes](#gateway-api-kubernetes)
- [服务、负载均衡和联网 | Kubernetes](#-kubernetes)
- [Dienste, Lastverteilung und Netzwerkfunktionen | Kubernetes](#dienste-lastverteilung-und-netzwerkfunktionen-kubernetes)
- [调试集群 | Kubernetes](#-kubernetes)
- [Notes | Kubernetes](#notes-kubernetes)
- [Kubernetes 问题和安全 | Kubernetes](#kubernetes-kubernetes)
- [Berkontribusi ke Dokumentasi Kubernetes | Kubernetes](#berkontribusi-ke-dokumentasi-kubernetes-kubernetes)
- [টাস্ক | Kubernetes](#-kubernetes)
- [Image | Kubernetes](#image-kubernetes)
- [Aplicaciones Stateless | Kubernetes](#aplicaciones-stateless-kubernetes)
- [কুবারনেটিসে অবদান | Kubernetes](#-kubernetes)
- [Container | Kubernetes](#container-kubernetes)
- [Огляд | Kubernetes](#-kubernetes)
- [Configurar pods y contenedores | Kubernetes](#configurar-pods-y-contenedores-kubernetes)
- [Проблемы и безопасность Kubernetes | Kubernetes](#-kubernetes-kubernetes)
- [Extender la API de Kubernetes | Kubernetes](#extender-la-api-de-kubernetes-kubernetes)
- [Speicher | Kubernetes](#speicher-kubernetes)
- [Inyectar datos en las aplicaciones | Kubernetes](#inyectar-datos-en-las-aplicaciones-kubernetes)
- [네트워킹 레퍼런스 | Kubernetes](#-kubernetes)
- [Administrar un clúster | Kubernetes](#administrar-un-cl-ster-kubernetes)
- [Herramientas de configuración | Kubernetes](#herramientas-de-configuraci-n-kubernetes)
- [ターンキークラウドソリューション | Kubernetes](#-kubernetes)
- [স্টোরেজ | Kubernetes](#-kubernetes)
- [ネットワーキングのリファレンス | Kubernetes](#-kubernetes)
- [সার্ভিস, লোড ব্যালেন্সিং এবং নেটওয়ার্কিং | Kubernetes](#-kubernetes)
- [最佳实践 | Kubernetes](#-kubernetes)
- [Расширения Kubernetes | Kubernetes](#-kubernetes-kubernetes)
- [Setup | Kubernetes](#setup-kubernetes)
- [Services | Kubernetes](#services-kubernetes)
- [Gestionar y ejecutar aplicaciones | Kubernetes](#gestionar-y-ejecutar-aplicaciones-kubernetes)
- [Praktek-praktek Terbaik | Kubernetes](#praktek-praktek-terbaik-kubernetes)
- [Tổng quan | Kubernetes](#t-ng-quan-kubernetes)
- [Среда обучения | Kubernetes](#-kubernetes)
- [Monitoreo, Logging y Depuración | Kubernetes](#monitoreo-logging-y-depuraci-n-kubernetes)
- [Políticas | Kubernetes](#pol-ticas-kubernetes)
- [클러스터 아키텍처 | Kubernetes](#-kubernetes)
- [Contribuir a la documentación de Kubernetes | Kubernetes](#contribuir-a-la-documentaci-n-de-kubernetes-kubernetes)
- [Kontainer | Kubernetes](#kontainer-kubernetes)
- [Kubernetes Configuration Good Practices | Kubernetes](#kubernetes-configuration-good-practices-kubernetes)
- [Administration d'un cluster | Kubernetes](#administration-d-un-cluster-kubernetes)
- [Настройка | Kubernetes](#-kubernetes)
- [কুবারনেটিসে উইন্ডোজ | Kubernetes](#-kubernetes)
- [节点参考信息 | Kubernetes](#-kubernetes)
- [কনফিগারেশন | Kubernetes](#-kubernetes)
- [API 접근 제어 | Kubernetes](#api-kubernetes)
- [SIG Docsへの参加 | Kubernetes](#sig-docs-kubernetes)
- [Contêineres | Kubernetes](#cont-ineres-kubernetes)
- [Arquitectura de Kubernetes | Kubernetes](#arquitectura-de-kubernetes-kubernetes)
- [쿠버네티스 이슈와 보안 | Kubernetes](#-kubernetes)
- [ベストプラクティス | Kubernetes](#-kubernetes)
- [Seguridad | Kubernetes](#seguridad-kubernetes)
- [শিডিউলিং, প্রিএম্পশন এবং ইভিকশন (Scheduling, Preemption and Eviction) | Kubernetes](#-scheduling-preemption-and-eviction-kubernetes)
- [TLS | Kubernetes](#tls-kubernetes)
- [নীতিমালা | Kubernetes](#-kubernetes)
- [쿠버네티스 기초 학습 | Kubernetes](#-kubernetes)
- [セットアップツールのリファレンス | Kubernetes](#-kubernetes)
- [노드 레퍼런스 정보 | Kubernetes](#-kubernetes)
- [設定 | Kubernetes](#-kubernetes)
- [セキュリティ | Kubernetes](#-kubernetes)
---
# Overview | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/concepts/overview/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/concepts/overview/)
.
Overview
========
* 1: [Cos'è Kubernetes?](https://kubernetes.io/it/docs/concepts/overview/_print/#pg-45bdca6129cf540121623e903c18ba46)
* 2: [I componenti di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/_print/#pg-13b0f1dbe89228e3d76d2ac231e245f1)
* 3: [Le API di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/_print/#pg-0c745f42e623d2b70a53bc0e6db73d95)
1 - Cos'è Kubernetes?
=====================
Kubernetes è una piattaforma portatile, estensibile e open-source per la gestione di carichi di lavoro e servizi containerizzati, in grado di facilitare sia la configurazione dichiarativa che l'automazione. La piattaforma vanta un grande ecosistema in rapida crescita. Servizi, supporto e strumenti sono ampiamente disponibili nel mondo Kubernetes .
Questa pagina è una panoramica generale su Kubernetes.
Kubernetes è una piattaforma portatile, estensibile e open-source per la gestione di carichi di lavoro e servizi containerizzati, in grado di facilitare sia la configurazione dichiarativa che l'automazione. La piattaforma vanta un grande ecosistema in rapida crescita. Servizi, supporto e strumenti sono ampiamente disponibili nel mondo Kubernetes .
Il nome Kubernetes deriva dal greco, significa timoniere o pilota. Google ha reso open-source il progetto Kubernetes nel 2014. Kubernetes unisce [oltre quindici anni di esperienza di Google](https://kubernetes.io/blog/2015/04/borg-predecessor-to-kubernetes/)
nella gestione di carichi di lavoro di produzione su scala mondiale con le migliori idee e pratiche della comunità.
Facciamo un piccolo salto indietro
----------------------------------
Diamo un'occhiata alla ragione per cui Kubernetes è così utile facendo un piccolo salto indietro nel tempo.

**L'era del deployment tradizionale:** All'inizio, le organizzazioni eseguivano applicazioni su server fisici. Non c'era modo di definire i limiti delle risorse per le applicazioni in un server fisico e questo ha causato non pochi problemi di allocazione delle risorse. Ad esempio, se più applicazioni vengono eseguite sullo stesso server fisico, si possono verificare casi in cui un'applicazione assorbe la maggior parte delle risorse e, di conseguenza, le altre applicazioni non hanno le prestazioni attese. Una soluzione per questo sarebbe di eseguire ogni applicazione su un server fisico diverso. Ma questa non è una soluzione ideale, dal momento che le risorse vengono sottoutilizzate, inoltre, questa pratica risulta essere costosa per le organizzazioni, le quali devono mantenere numerosi server fisici.
**L'era del deployment virtualizzato:** Come soluzione venne introdotta la virtualizzazione. Essa consente di eseguire più macchine virtuali (VM) su una singola CPU fisica. La virtualizzazione consente di isolare le applicazioni in più macchine virtuali e fornisce un livello di sicurezza superiore, dal momento che le informazioni di un'applicazione non sono liberamente accessibili da un'altra applicazione.
La virtualizzazione consente un migliore utilizzo delle risorse riducendo i costi per l'hardware, permette una migliore scalabilità, dato che un'applicazione può essere aggiunta o aggiornata facilmente, e ha molti altri vantaggi.
Ogni VM è una macchina completa che esegue tutti i componenti, compreso il proprio sistema operativo, sopra all'hardware virtualizzato.
**L'era del deployment in container:** I container sono simili alle macchine virtuali, ma presentano un modello di isolamento più leggero, condividendo il sistema operativo (OS) tra le applicazioni. Pertanto, i container sono considerati più leggeri. Analogamente a una macchina virtuale, un container dispone di una segregazione di filesystem, CPU, memoria, PID e altro ancora. Poiché sono disaccoppiati dall'infrastruttura sottostante, risultano portabili tra differenti cloud e diverse distribuzioni.
I container sono diventati popolari dal momento che offrono molteplici vantaggi, ad esempio:
* Creazione e distribuzione di applicazioni in modalità Agile: maggiore facilità ed efficienza nella creazione di immagini container rispetto all'uso di immagini VM.
* Adozione di pratiche per lo sviluppo/test/rilascio continuativo: consente la frequente creazione e la distribuzione di container image affidabili, dando la possibilità di fare rollback rapidi e semplici (grazie all'immutabilità dell'immagine stessa).
* Separazione delle fasi di Dev e Ops: le container image vengono prodotte al momento della compilazione dell'applicativo piuttosto che nel momento del rilascio, permettendo così di disaccoppiare le applicazioni dall'infrastruttura sottostante.
* L'osservabilità non riguarda solo le informazioni e le metriche del sistema operativo, ma anche lo stato di salute e altri segnali dalle applicazioni.
* Coerenza di ambiente tra sviluppo, test e produzione: i container funzionano allo stesso modo su un computer portatile come nel cloud.
* Portabilità tra cloud e sistemi operativi differenti: lo stesso container funziona su Ubuntu, RHEL, CoreOS, on-premise, nei più grandi cloud pubblici e da qualsiasi altra parte.
* Gestione incentrata sulle applicazioni: Aumenta il livello di astrazione dall'esecuzione di un sistema operativo su hardware virtualizzato all'esecuzione di un'applicazione su un sistema operativo utilizzando risorse logiche.
* Microservizi liberamente combinabili, distribuiti, ad alta scalabilità: le applicazioni sono suddivise in pezzi più piccoli e indipendenti che possono essere distribuite e gestite dinamicamente - niente stack monolitici che girano su una singola grande macchina.
* Isolamento delle risorse: le prestazioni delle applicazioni sono prevedibili.
* Utilizzo delle risorse: alta efficienza e densità.
Perché necessito di Kubernetes e cosa posso farci
-------------------------------------------------
I container sono un buon modo per distribuire ed eseguire le tue applicazioni. In un ambiente di produzione, è necessario gestire i container che eseguono le applicazioni e garantire che non si verifichino interruzioni dei servizi. Per esempio, se un container si interrompe, è necessario avviare un nuovo container. Non sarebbe più facile se questo comportamento fosse gestito direttamente da un sistema?
È proprio qui che Kubernetes viene in soccorso! Kubernetes ti fornisce un framework per far funzionare i sistemi distribuiti in modo resiliente. Kubernetes si occupa della scalabilità, failover, distribuzione delle tue applicazioni. Per esempio, Kubernetes può facilmente gestire i rilasci con modalità Canary deployment.
Kubernetes ti fornisce:
* **Scoperta dei servizi e bilanciamento del carico** Kubernetes può esporre un container usando un nome DNS o il suo indirizzo IP. Se il traffico verso un container è alto, Kubernetes è in grado di distribuire il traffico su più container in modo che il servizio rimanga stabile.
* **Orchestrazione dello storage** Kubernetes ti permette di montare automaticamente un sistema di archiviazione di vostra scelta, come per esempio storage locale, dischi forniti da cloud pubblici, e altro ancora.
* **Rollout e rollback automatizzati** Puoi utilizzare Kubernetes per descrivere lo stato desiderato per i propri container, e Kubernetes si occuperà di cambiare lo stato attuale per raggiungere quello desiderato ad una velocità controllata. Per esempio, puoi automatizzare Kubernetes per creare nuovi container per il tuo servizio, rimuovere i container esistenti e adattare le loro risorse a quelle richieste dal nuovo container.
* **Ottimizzazione dei carichi** Fornisci a Kubernetes un cluster di nodi per eseguire i container. Puoi istruire Kubernetes su quanta CPU e memoria (RAM) ha bisogno ogni singolo container. Kubernetes allocherà i container sui nodi per massimizzare l'uso delle risorse a disposizione.
* **Self-healing** Kubernetes riavvia i container che si bloccano, sostituisce container, termina i container che non rispondono agli health checks, e evita di far arrivare traffico ai container che non sono ancora pronti per rispondere correttamente.
* **Gestione di informazioni sensibili e della configurazione** Kubernetes consente di memorizzare e gestire informazioni sensibili, come le password, i token OAuth e le chiavi SSH. Puoi distribuire e aggiornare le informazioni sensibili e la configurazione dell'applicazione senza dover ricostruire le immagini dei container e senza svelare le informazioni sensibili nella configurazione del tuo sistema.
Cosa non è Kubernetes
---------------------
Kubernetes non è un sistema PaaS (Platform as a Service) tradizionale e completo. Dal momento che Kubernetes opera a livello di container piuttosto che che a livello hardware, esso fornisce alcune caratteristiche generalmente disponibili nelle offerte PaaS, come la distribuzione, il ridimensionamento, il bilanciamento del carico, la registrazione e il monitoraggio. Tuttavia, Kubernetes non è monolitico, e queste soluzioni predefinite sono opzionali ed estensibili. Kubernetes fornisce gli elementi base per la costruzione di piattaforme di sviluppo, ma conserva le scelte dell'utente e la flessibilità dove è importante.
Kubernetes:
* Non limita i tipi di applicazioni supportate. Kubernetes mira a supportare una grande varietà di carichi di lavoro, compresi i carichi di lavoro stateless, stateful e elaborazione di dati. Se un'applicazione può essere eseguita in un container, dovrebbe funzionare alla grande anche su Kubernetes.
* Non compila il codice sorgente e non crea i container. I flussi di Continuous Integration, Delivery, and Deployment (CI/CD) sono determinati dalla cultura e dalle preferenze dell'organizzazione e dai requisiti tecnici.
* Non fornisce servizi a livello applicativo, come middleware (per esempio, bus di messaggi), framework di elaborazione dati (per esempio, Spark), database (per esempio, mysql), cache, né sistemi di storage distribuito (per esempio, Ceph) come servizi integrati. Tali componenti possono essere eseguiti su Kubernetes, e/o possono essere richiamati da applicazioni che girano su Kubernetes attraverso meccanismi come l'[Open Service Broker](https://openservicebrokerapi.org/)
.
* Non impone soluzioni di logging, monitoraggio o di gestione degli alert. Fornisce alcune integrazioni come dimostrazione, e meccanismi per raccogliere ed esportare le metriche.
* Non fornisce né rende obbligatorio un linguaggio/sistema di configurazione (per esempio, Jsonnet). Fornisce un'API dichiarativa che può essere richiamata da qualsiasi sistema.
* Non fornisce né adotta alcun sistema di gestione completa della macchina, configurazione, manutenzione, gestione o sistemi di self healing.
* Inoltre, Kubernetes non è un semplice sistema di orchestrazione. Infatti, questo sistema elimina la necessità di orchestrazione. La definizione tecnica di orchestrazione è l'esecuzione di un flusso di lavoro definito: prima si fa A, poi B, poi C. Al contrario, Kubernetes è composto da un insieme di processi di controllo indipendenti e componibili che guidano costantemente lo stato attuale verso lo stato desiderato. Non dovrebbe importare come si passa dalla A alla C. Anche il controllo centralizzato non è richiesto. Questo si traduce in un sistema più facile da usare, più potente, robusto, resiliente ed estensibile.
Voci correlate
--------------
* Dai un'occhiata alla pagina [i componenti di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/components/)
* Sai già [Come Iniziare](https://kubernetes.io/docs/setup/)
?
2 - I componenti di Kubernetes
==============================
Un cluster di Kubernetes è costituito da un insieme di componenti che sono, come minimo, un Control Plane e uno o più sistemi di elaborazione, detti nodi.
Facendo il deployment di Kubernetes, ottieni un cluster.
Un cluster Kubernetes è un'insieme di macchine, chiamate nodi, che eseguono container gestiti da Kubernetes. Un cluster ha almeno un Worker Node.
Il/I Worker Node ospitano i Pod che eseguono i workload dell'utente. Il/I Control Plane Node gestiscono i Worker Node e tutto quanto accade all'interno del cluster. Per garantire la high-availability e la possibilità di failover del cluster, vengono utilizzati più Control Plane Node.
Questo documento descrive i diversi componenti che sono necessari per avere un cluster Kubernetes completo e funzionante.
Questo è un diagramma di un cluster Kubernetes con tutti i componenti e le loro relazioni.

Componenti della Control Plane
------------------------------
I componenti del Control Plane sono responsabili di tutte le decisioni globali sul cluster (ad esempio, lo scheduling) oltre che a rilevare e rispondere agli eventi del cluster (ad esempio, l'avvio di un nuovo [pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
quando il valore `replicas` di un deployment non è soddisfatto).
I componenti della Control Plane possono essere eseguiti su qualsiasi nodo del cluster stesso. Solitamente, per semplicità, gli script di installazione tendono a eseguire tutti i componenti della Control Plane sulla stessa macchina, separando la Control Plane dai workload dell'utente. Vedi [creare un cluster in High-Availability](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/)
per un esempio di un'installazione multi-master.
### kube-apiserver
L'API server è un componente di Kubernetes [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
che espone le Kubernetes API. L'API server è il front end del control plane di Kubernetes.
La principale implementazione di un server Kubernetes API è [kube-apiserver](https://kubernetes.io/docs/reference/generated/kube-apiserver/)
. kube-apiserver è progettato per scalare orizzontalmente, cioè scala aumentando il numero di istanze. Puoi eseguire multiple istanze di kube-apiserver e bilanciare il traffico tra queste istanze.
### etcd
È un database key-value ridondato, che è usato da Kubernetes per salvare tutte le informazioni del cluster.
Se il tuo cluster utilizza etcd per salvare le informazioni, assicurati di avere una strategia di [backup](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/#backing-up-an-etcd-cluster)
per questi dati.
Puoi trovare informazioni dettagliate su etcd sulla [documentazione](https://etcd.io/docs/)
ufficiale.
### kube-scheduler
Componente della Control Plane che controlla i pod appena creati che non hanno un nodo assegnato, e dopo averlo identificato glielo assegna.
I fattori presi in considerazioni nell'individuare un nodo a cui assegnare l'esecuzione di un Pod includono la richiesta di risorse del Pod stesso e degli altri workload presenti nel sistema, i vincoli delle hardware/software/policy, le indicazioni di affinity e di anti-affinity, requisiti relativi alla disponibilità di dati/Volumes, le interferenze tra diversi workload e le scadenze.
### kube-controller-manager
Componente della Control Plane che gestisce [controllers](https://kubernetes.io/it/docs/concepts/architecture/controller/ "Un software che implementa un circuito di controllo che osserva lo stato condiviso del cluster attraverso l'API server e apporta le modifiche necessarie per portate lo stato corrente verso lo stato desiderato.")
.
Da un punto di vista logico, ogni [controller](https://kubernetes.io/it/docs/concepts/architecture/controller/ "Un software che implementa un circuito di controllo che osserva lo stato condiviso del cluster attraverso l'API server e apporta le modifiche necessarie per portate lo stato corrente verso lo stato desiderato.")
è un processo separato, ma per ridurre la complessità, tutti i principali controller di Kubernetes vengono raggruppati in un unico container ed eseguiti in un singolo processo.
Alcuni esempi di controller gestiti dal kube-controller-manager sono:
* Node Controller: Responsabile del monitoraggio dei nodi del cluster, e.g. della gestione delle azioni da eseguire quando un nodo diventa non disponibile.
* Replication Controller: Responsabile per il mantenimento del corretto numero di Pod per ogni ReplicaSet presente nel sistema
* Endpoints Controller: Popola gli oggetti Endpoints (cioè, mette in relazioni i Pods con i Services).
* Service Account & Token Controllers: Creano gli account di default e i token di accesso alle API per i nuovi namespaces.
### cloud-controller-manager
Un componente della [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
di Kubernetes che aggiunge logiche di controllo specifiche per il cloud. Il cloud-controller-manager ti permette di collegare il tuo cluster con le API del cloud provider e separa le componenti che interagiscono con la piattaforma cloud dai componenti che interagiscono solamente col cluster.
Il cloud-controller-manager esegue dei controller specifici del tuo cloud provider. Se hai una installazione Kubernetes on premises, o un ambiente di laboratorio nel tuo PC, il cluster non ha un cloud-controller-manager.
Come nel kube-controller-manager, il cloud-controller-manager combina diversi control loop logicamente indipendenti in un singolo binario che puoi eseguire come un singolo processo. Tu puoi scalare orizzontalmente (eseguire più di una copia) per migliorare la responsività o per migliorare la tolleranza ai fallimenti.
I seguenti controller hanno dipendenze verso implementazioni di specifici cloud provider:
* Node Controller: Per controllare se sul cloud provider i nodi che hanno smesso di rispondere sono stati cancellati
* Route Controller: Per configurare le network route nella sottostante infrastruttura cloud
* Service Controller: Per creare, aggiornare ed eliminare i load balancer del cloud provider
Componenti dei Nodi
-------------------
I componenti del nodo vengono eseguiti su ogni nodo, mantenendo i pod in esecuzione e fornendo l'ambiente di runtime Kubernetes.
### kubelet
Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.
La kubelet riceve un set di PodSpecs che vengono forniti attraverso vari meccanismi, e si assicura che i container descritti in questi PodSpecs funzionino correttamente e siano sani. La kubelet non gestisce i container che non sono stati creati da Kubernetes.
### kube-proxy
[kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/)
è un proxy eseguito su ogni nodo del cluster, responsabile della gestione dei Kubernetes [Service](https://kubernetes.io/it/docs/concepts/services-networking/service/ "A way to expose an application running on a set of Pods as a network service.")
.
I kube-proxy mantengono le regole di networking sui nodi. Queste regole permettono la comunicazione verso gli altri nodi del cluster o l'esterno.
Il kube-proxy usa le librerie del sistema operativo quando possible; in caso contrario il kube-proxy gestisce il traffico direttamente.
### Container Runtime
Il container runtime è il software che è responsabile per l'esecuzione dei container.
Kubernetes supporta diversi container runtimes: [Docker](http://www.docker.com/)
, [containerd](https://containerd.io/)
, [cri-o](https://cri-o.io/)
, [rktlet](https://github.com/kubernetes-incubator/rktlet)
e tutte le implementazioni di [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Addons
------
Gli Addons usano le risorse Kubernetes ([DaemonSet](https://kubernetes.io/it/docs/concepts/workloads/controllers/daemonset "Assicura che una copia di un Pod è attiva su tutti nodi di un cluster.")
, [Deployment](https://kubernetes.io/it/docs/concepts/workloads/controllers/deployment/ "Gestisce una applicazione replicata nel tuo cluster.")
, etc) per implementare funzionalità di cluster. Dal momento che gli addons forniscono funzionalità a livello di cluster, le risorse che necessitano di un namespace, vengono collocate nel namespace `kube-system`.
Alcuni addons sono descritti di seguito; mentre per una più estesa lista di addons, per favore vedere [Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
.
### DNS
Mentre gli altri addons non sono strettamente richiesti, tutti i cluster Kubernetes dovrebbero essere muniti di un [DNS del cluster](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)
, dal momento che molte applicazioni lo necessitano.
Il DNS del cluster è un server DNS aggiuntivo rispetto ad altri server DNS presenti nella rete, e si occupa specificatamente dei record DNS per i servizi Kubernetes.
I container eseguiti da Kubernetes automaticamente usano questo server per la risoluzione DNS.
### Interfaccia web (Dashboard)
La [Dashboard](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)
è una interfaccia web per i cluster Kubernetes. Permette agli utenti di gestire e fare troubleshooting delle applicazioni che girano nel cluster, e del cluster stesso.
### Monitoraggio dei Container
Il [Monitoraggio dei Container](https://kubernetes.io/docs/tasks/debug-application-cluster/resource-usage-monitoring/)
salva serie temporali di metriche generiche dei container in un database centrale e fornisce una interfaccia in cui navigare i dati stessi.
### Log a livello di Cluster
Un [log a livello di cluster](https://kubernetes.io/docs/concepts/cluster-administration/logging/)
è responsabile per il salvataggio dei log dei container in un log centralizzato la cui interfaccia permette di cercare e navigare nei log.
Voci correlate
--------------
* Scopri i concetti relativi ai [Nodi](https://kubernetes.io/docs/concepts/architecture/nodes/)
* Scopri i concetti relativi ai [Controller](https://kubernetes.io/it/docs/concepts/architecture/controller/)
* Scopri i concetti relativi al [kube-scheduler](https://kubernetes.io/docs/concepts/scheduling/kube-scheduler/)
* Leggi la [documentazione](https://etcd.io/docs/)
ufficiale di etcd
3 - Le API di Kubernetes
========================
Le API di Kubernetes ti permettono di interrogare e manipolare lo stato degli oggetti in Kubernetes. Il cuore del Control Plane di Kubernetes è l'API server e le API HTTP che esso espone. Ogni entità o componente che si interfaccia con il cluster (gli utenti, le singole parti del tuo cluster, i componenti esterni), comunica attraverso l'API server.
Le convenzioni generali seguite dalle API sono descritte in [API conventions doc](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md)
.
Gli _endpoints_ delle API, la lista delle risorse esposte ed i relativi esempi sono descritti in [API Reference](https://kubernetes.io/docs/reference)
.
L'accesso alle API da remoto è discusso in [Controllare l'accesso alle API](https://kubernetes.io/docs/reference/access-authn-authz/controlling-access/)
.
Le API di Kubernetes servono anche come riferimento per lo schema dichiarativo della configurazione del sistema stesso. Il comando [kubectl](https://kubernetes.io/docs/reference/kubectl/overview/)
può essere usato per creare, aggiornare, cancellare ed ottenere le istanze delle risorse esposte attraverso le API.
Kubernetes assicura la persistenza del suo stato (al momento in [etcd](https://coreos.com/docs/distributed-configuration/getting-started-with-etcd/)
) usando la rappresentazione delle risorse implementata dalle API.
Kubernetes stesso è diviso in differenti componenti, i quali interagiscono tra loro attraverso le stesse API.
Evoluzione delle API
--------------------
In base alla nostra esperienza, ogni sistema di successo ha bisogno di evolvere ovvero deve estendersi aggiungendo funzionalità o modificare le esistenti per adattarle a nuovi casi d'uso. Le API di Kubernetes sono quindi destinate a cambiare e ad estendersi. In generale, ci si deve aspettare che nuove risorse vengano aggiunte di frequente cosi come nuovi campi possano altresì essere aggiunti a risorse esistenti. L'eliminazione di risorse o di campi devono seguire la [politica di deprecazione delle API](https://kubernetes.io/docs/reference/using-api/deprecation-policy/)
.
In cosa consiste una modifica compatibile e come modificare le API è descritto dal [API change document](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md)
.
Definizioni OpenAPI e Swagger
-----------------------------
La documentazione completa e dettagliata delle API è fornita attraverso la specifica [OpenAPI](https://www.openapis.org/)
.
Dalla versione 1.10 di Kubernetes, l'API server di Kubernetes espone le specifiche OpenAPI attraverso il seguente _endpoint_ `/openapi/v2`. Attraverso i seguenti _headers_ HTTP è possibile richiedere un formato specifico:
| Header | Possibili Valori |
| --- | --- |
| Accept | `application/json`, `application/com.github.proto-openapi.spec.v2@v1.0+protobuf` (il content-type di default è `application/json` per `*/*` ovvero questo header può anche essere omesso) |
| Accept-Encoding | `gzip` (questo header è facoltativo) |
Prima della versione 1.14, gli _endpoints_ che includono il formato del nome all'interno del segmento (`/swagger.json`, `/swagger-2.0.0.json`, `/swagger-2.0.0.pb-v1`, `/swagger-2.0.0.pb-v1.gz`) espongo le specifiche OpenAPI in formati differenti. Questi _endpoints_ sono deprecati, e saranno rimossi dalla versione 1.14 di Kubernetes.
**Esempi per ottenere le specifiche OpenAPI**:
| Prima della 1.10 | Dalla versione 1.10 di Kubernetes |
| --- | --- |
| GET /swagger.json | GET /openapi/v2 **Accept**: application/json |
| GET /swagger-2.0.0.pb-v1 | GET /openapi/v2 **Accept**: [application/com.github.proto-openapi.spec.v2@v1.0](mailto:application/com.github.proto-openapi.spec.v2@v1.0) +protobuf |
| GET /swagger-2.0.0.pb-v1.gz | GET /openapi/v2 **Accept**: [application/com.github.proto-openapi.spec.v2@v1.0](mailto:application/com.github.proto-openapi.spec.v2@v1.0) +protobuf **Accept-Encoding**: gzip |
Kubernetes implementa per le sue API anche una serializzazione alternativa basata sul formato Protobuf che è stato pensato principalmente per la comunicazione intra-cluster, documentato nella seguente [design proposal](https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/protobuf.md)
, e i files IDL per ciascun schema si trovano nei _Go packages_ che definisco i tipi delle API.
Prima della versione 1.14, l'_apiserver_ di Kubernetes espone anche un'_endpoint_, `/swaggerapi`, che può essere usato per ottenere le documentazione per le API di Kubernetes secondo le specifiche [Swagger v1.2](http://swagger.io/)
. Questo _endpoint_ è deprecato, ed è stato rimosso nella versione 1.14 di Kubernetes.
Versionamento delle API
-----------------------
Per facilitare l'eliminazione di campi specifici o la modifica della rappresentazione di una data risorsa, Kubernetes supporta molteplici versioni della stessa API disponibili attraverso differenti indirizzi, come ad esempio `/api/v1` oppure `/apis/extensions/v1beta1`.
Abbiamo deciso di versionare a livello di API piuttosto che a livello di risorsa o di campo per assicurare che una data API rappresenti una chiara, consistente vista delle risorse di sistema e dei sui comportamenti, e per abilitare un controllo degli accessi sia per le API in via di decommissionamento che per quelle sperimentali.
Si noti che il versionamento delle API ed il versionamento del Software sono indirettamente collegati. La [API and release versioning proposal](https://git.k8s.io/community/contributors/design-proposals/release/versioning.md)
descrive la relazione tra le versioni delle API ed le versioni del Software.
Differenti versioni delle API implicano differenti livelli di stabilità e supporto. I criteri per ciascuno livello sono descritti in dettaglio nella [API Changes documentation](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md#alpha-beta-and-stable-versions)
. Queste modifiche sono qui ricapitolate:
* Livello alpha:
* Il nome di versione contiene `alpha` (e.g. `v1alpha1`).
* Potrebbe contenere dei _bug_. Abilitare questa funzionalità potrebbe esporre al rischio di _bugs_. Disabilitata di default.
* Il supporto di questa funzionalità potrebbe essere rimosso in ogni momento senza previa notifica.
* Questa API potrebbe cambiare in modo incompatibile in rilasci futuri del Software e senza previa notifica.
* Se ne raccomandata l'utilizzo solo in _clusters_ di test creati per un breve periodo di vita, a causa di potenziali _bugs_ e delle mancanza di un supporto di lungo periodo.
* Livello beta:
* Il nome di versione contiene `beta` (e.g. `v2beta3`).
* Il codice è propriamente testato. Abilitare la funzionalità è considerato sicuro. Abilitata di default.
* Il supporto per la funzionalità nel suo complesso non sarà rimosso, tuttavia potrebbe subire delle modifiche.
* Lo schema e/o la semantica delle risorse potrebbe cambiare in modo incompatibile in successivi rilasci beta o stabili. Nel caso questo dovesse verificarsi, verrano fornite istruzioni per la migrazione alla versione successiva. Questo potrebbe richiedere la cancellazione, modifica, e la ri-creazione degli oggetti supportati da questa API. Questo processo di modifica potrebbe richiedere delle valutazioni. La modifica potrebbe richiedere un periodo di non disponibilità dell'applicazione che utilizza questa funzionalità.
* Raccomandata solo per applicazioni non critiche per la vostra impresa a causa dei potenziali cambiamenti incompatibili in rilasci successivi. Se avete più _clusters_ che possono essere aggiornati separatamente, potreste essere in grado di gestire meglio questa limitazione.
* **Per favore utilizzate le nostre versioni beta e forniteci riscontri relativamente ad esse! Una volta promosse a stabili, potrebbe non essere semplice apportare cambiamenti successivi.**
* Livello stabile:
* Il nome di versione è `vX` dove `X` è un intero.
* Le funzionalità relative alle versioni stabili continueranno ad essere presenti per parecchie versioni successive.
API groups
----------
Per facilitare l'estendibilità delle API di Kubernetes, sono stati implementati gli [_API groups_](https://git.k8s.io/community/contributors/design-proposals/api-machinery/api-group.md)
.
L'_API group_ è specificato nel percorso REST ed anche nel campo `apiVersion` di un oggetto serializzato.
Al momento ci sono diversi _API groups_ in uso:
1. Il gruppo _core_, spesso referenziato come il _legacy group_, è disponibile al percorso REST `/api/v1` ed utilizza `apiVersion: v1`.
2. I gruppi basati su un nome specifico sono disponibili attraverso il percorso REST `/apis/$GROUP_NAME/$VERSION`, ed usano `apiVersion: $GROUP_NAME/$VERSION` (e.g. `apiVersion: batch/v1`). La lista completa degli _API groups_ supportati e' descritta nel documento [Kubernetes API reference](https://kubernetes.io/docs/reference/)
.
Vi sono due modi per supportati per estendere le API attraverso le [_custom resources_](https://kubernetes.io/docs/concepts/api-extension/custom-resources/)
:
1. [CustomResourceDefinition](https://kubernetes.io/docs/tasks/access-kubernetes-api/extend-api-custom-resource-definitions/)
è pensato per utenti con esigenze CRUD basilari.
2. Utenti che necessitano di un nuovo completo set di API che utilizzi appieno la semantica di Kubernetes possono implementare il loro _apiserver_ ed utilizzare l'[_aggregator_](https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/)
per fornire ai propri utilizzatori la stessa esperienza a cui sono abituati con le API incluse nativamente in Kubernetes.
Abilitare o disabilitare gli _API groups_
-----------------------------------------
Alcune risorse ed _API groups_ sono abilitati di default. Questi posso essere abilitati o disabilitati attraverso il settaggio/flag `--runtime-config` applicato sull'_apiserver_. `--runtime-config` accetta valori separati da virgola. Per esempio: per disabilitare `batch/v1`, usa la seguente configurazione `--runtime-config=batch/v1=false`, per abilitare `batch/v2alpha1`, utilizzate `--runtime-config=batch/v2alpha1`.
Il _flag_ accetta set di coppie _chiave/valore_ separati da virgola che descrivono la configurazione a _runtime_ dell'_apiserver_.
#### Nota:
Abilitare o disabilitare risorse o gruppi richiede il riavvio dell'_apiserver_ e del _controller-manager_ affinché le modifiche specificate attraverso il flag `--runtime-config` abbiano effetto.
Abilitare specifiche risorse nel gruppo extensions/v1beta1
----------------------------------------------------------
DaemonSets, Deployments, StatefulSet, NetworkPolicies, PodSecurityPolicies e ReplicaSets presenti nel gruppo di API `extensions/v1beta1` sono disabilitate di default. Per esempio: per abilitare deployments and daemonsets, utilizza la seguente configurazione `--runtime-config=extensions/v1beta1/deployments=true,extensions/v1beta1/daemonsets=true`.
#### Nota:
Abilitare/disabilitare una singola risorsa è supportato solo per il gruppo di API `extensions/v1beta1` per ragioni storiche.
---
# Instalasi Add-ons | Kubernetes
**Information in this document may be out of date**
This document has an older update date than the original, so the information it contains may be out of date. If you're able to read English, see the English version for the most up-to-date information: [Installing Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
Instalasi Add-ons
=================
_Add-ons_ berfungsi untuk menambah serta memperluas fungsionalitas dari Kubernetes.
Laman ini akan menjabarkan beberapa _add-ons_ yang tersedia serta tautan instruksi bagaimana cara instalasi masing-masing _add-ons_.
_Add-ons_ pada setiap bagian akan diurutkan secara alfabet - pengurutan ini tidak dilakukan berdasarkan status preferensi atau keunggulan.
Jaringan dan _Policy_ Jaringan
------------------------------
* [ACI](https://www.github.com/noironetworks/aci-containers)
menyediakan integrasi jaringan kontainer dan keamanan jaringan dengan Cisco ACI.
* [Calico](https://docs.projectcalico.org/latest/getting-started/kubernetes/)
merupakan penyedia jaringan L3 yang aman dan _policy_ jaringan.
* [Canal](https://projectcalico.docs.tigera.io/getting-started/kubernetes/flannel/flannel)
menggabungkan Flannel dan Calico, menyediakan jaringan serta _policy_ jaringan.
* [Cilium](https://github.com/cilium/cilium)
merupakan _plugin_ jaringan L3 dan _policy_ jaringan yang dapat menjalankan _policy_ HTTP/API/L7 secara transparan. Mendukung mode _routing_ maupun _overlay/encapsulation_.
* [CNI-Genie](https://github.com/cni-genie/CNI-Genie)
memungkinkan Kubernetes agar dapat terkoneksi dengan beragam _plugin_ CNI, seperti Calico, Canal, Flannel, Romana, atau Weave dengan mulus.
* [Contiv](https://contivpp.io/)
menyediakan jaringan yang dapat dikonfigurasi (_native_ L3 menggunakan BGP, _overlay_ menggunakan vxlan, klasik L2, dan Cisco-SDN/ACI) untuk berbagai penggunaan serta _policy framework_ yang kaya dan beragam. Proyek Contiv merupakan proyek [open source](https://github.com/contiv)
. Laman [instalasi](https://github.com/contiv/install)
ini akan menjabarkan cara instalasi, baik untuk klaster dengan kubeadm maupun non-kubeadm.
* [Contrail](http://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
, yang berbasis dari [Tungsten Fabric](https://tungsten.io/)
, merupakan sebuah proyek _open source_ yang menyediakan virtualisasi jaringan _multi-cloud_ serta platform manajemen _policy_. Contrail dan Tungsten Fabric terintegrasi dengan sistem orkestrasi lainnya seperti Kubernetes, OpenShift, OpenStack dan Mesos, serta menyediakan mode isolasi untuk mesin virtual (VM), kontainer/pod dan _bare metal_.
* [Flannel](https://github.com/flannel-io/flannel#deploying-flannel-manually)
merupakan penyedia jaringan _overlay_ yang dapat digunakan pada Kubernetes.
* [Knitter](https://github.com/ZTE/Knitter/)
merupakan solusi jaringan yang mendukung multipel jaringan pada Kubernetes.
* [Multus](https://github.com/k8snetworkplumbingwg/multus-cni)
merupakan sebuah multi _plugin_ agar Kubernetes mendukung multipel jaringan secara bersamaan sehingga dapat menggunakan semua _plugin_ CNI (contoh: Calico, Cilium, Contiv, Flannel), ditambah pula dengan SRIOV, DPDK, OVS-DPDK dan VPP pada _workload_ Kubernetes.
* [NSX-T](https://docs.vmware.com/en/VMware-NSX-T-Data-Center/index.html)
Container Plug-in (NCP) menyediakan integrasi antara VMware NSX-T dan orkestrator kontainer seperti Kubernetes, termasuk juga integrasi antara NSX-T dan platform CaaS/PaaS berbasis kontainer seperti _Pivotal Container Service_ (PKS) dan OpenShift.
* [Nuage](https://github.com/nuagenetworks/nuage-kubernetes/blob/v5.1.1-1/docs/kubernetes-1-installation.rst)
merupakan platform SDN yang menyediakan _policy-based_ jaringan antara Kubernetes Pods dan non-Kubernetes _environment_ dengan _monitoring_ visibilitas dan keamanan.
* [Romana](http://romana.io/)
merupakan solusi jaringan _Layer_ 3 untuk jaringan pod yang juga mendukung [_NetworkPolicy_ API](https://kubernetes.io/id/docs/concepts/services-networking/network-policies/)
. Instalasi Kubeadm _add-on_ ini tersedia [di sini](https://github.com/romana/romana/tree/master/containerize)
.
* [Weave Net](https://www.weave.works/docs/net/latest/kube-addon/)
menyediakan jaringan serta _policy_ jaringan, yang akan membawa kedua sisi dari partisi jaringan, serta tidak membutuhkan basis data eksternal.
_Service Discovery_
-------------------
* [CoreDNS](https://coredns.io/)
merupakan server DNS yang fleksibel, mudah diperluas yang dapat [diinstal](https://github.com/coredns/helm)
sebagai _in-cluster_ DNS untuk pod.
Visualisasi & Kontrol
---------------------
* [Dashboard](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
merupakan antarmuka web dasbor untuk Kubernetes.
_Add-ons_ Terdeprekasi
----------------------
Ada beberapa _add-on_ lain yang didokumentasikan pada direktori deprekasi [_cluster/addons_](https://git.k8s.io/kubernetes/cluster/addons)
.
_Add-on_ lain yang dipelihara dan dikelola dengan baik dapat ditulis di sini. Ditunggu PR-nya!
Masukan
-------
Apakah halaman ini membantu?
Ya Tidak
Terima kasih atas masukannya. Jika kamu mempunyai pertanyaan yang spesifik terkait bagaimana menggunakan Kubernetes, tanyakanlah di [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. Buat isu di repositori GitHub jika kamu ingin [laporkan problem](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
atau [beri saran perbaikan](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
Last modified February 17, 2025 at 12:52 AM PST: [\[id\] Fixed link for core dns helm charts (197ed17c77)](https://github.com/kubernetes/website/commit/197ed17c77a550a61010b7170b474d194c01237d)
---
# 安装扩展(Addon) | Kubernetes
**此文档中的信息可能已过时**
此文档的更新日期比原文晚,因此其中的信息可能已过时。如果能阅读英文,请查看英文版本以获取最新信息: [Installing Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
安装扩展(Addon)
===========
**说明:** 本部分链接到提供 Kubernetes 所需功能的第三方项目。Kubernetes 项目作者不负责这些项目。此页面遵循[CNCF 网站指南](https://github.com/cncf/foundation/blob/main/policies-guidance/website-guidelines.md)
,按字母顺序列出项目。要将项目添加到此列表中,请在提交更改之前阅读[内容指南](https://kubernetes.io/zh-cn/docs/contribute/style/content-guide/#third-party-content)
。
Add-on 扩展了 Kubernetes 的功能。
本文列举了一些可用的 add-on 以及到它们各自安装说明的链接。该列表并不试图详尽无遗。
联网和网络策略
-------
* [ACI](https://www.github.com/noironetworks/aci-containers)
通过 Cisco ACI 提供集成的容器网络和安全网络。
* [Antrea](https://antrea.io/)
在第 3/4 层执行操作,为 Kubernetes 提供网络连接和安全服务。Antrea 利用 Open vSwitch 作为网络的数据面。 Antrea 是一个[沙箱级的 CNCF 项目](https://www.cncf.io/projects/antrea/)
。
* [Calico](https://www.tigera.io/project-calico/)
是一个联网和网络策略供应商。 Calico 支持一套灵活的网络选项,因此你可以根据自己的情况选择最有效的选项,包括非覆盖和覆盖网络,带或不带 BGP。 Calico 使用相同的引擎为主机、Pod 和(如果使用 Istio 和 Envoy)应用程序在服务网格层执行网络策略。
* [Canal](https://projectcalico.docs.tigera.io/getting-started/kubernetes/flannel/flannel)
结合 Flannel 和 Calico,提供联网和网络策略。
* [Cilium](https://github.com/cilium/cilium)
是一种网络、可观察性和安全解决方案,具有基于 eBPF 的数据平面。 Cilium 提供了简单的 3 层扁平网络, 能够以原生路由(routing)和覆盖/封装(overlay/encapsulation)模式跨越多个集群, 并且可以使用与网络寻址分离的基于身份的安全模型在 L3 至 L7 上实施网络策略。 Cilium 可以作为 kube-proxy 的替代品;它还提供额外的、可选的可观察性和安全功能。 Cilium 是一个[毕业级别的 CNCF 项目](https://www.cncf.io/projects/cilium/)
。
* [CNI-Genie](https://github.com/cni-genie/CNI-Genie)
使 Kubernetes 无缝连接到 Calico、Canal、Flannel 或 Weave 等其中一种 CNI 插件。 CNI-Genie 是一个[沙箱级的 CNCF 项目](https://www.cncf.io/projects/cni-genie/)
。
* [Contiv](https://contivpp.io/)
为各种用例和丰富的策略框架提供可配置的网络 (带 BGP 的原生 L3、带 vxlan 的覆盖、标准 L2 和 Cisco-SDN/ACI)。 Contiv 项目完全[开源](https://github.com/contiv)
。 其[安装程序](https://github.com/contiv/install)
提供了基于 kubeadm 和非 kubeadm 的安装选项。
* [Contrail](https://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
基于 [Tungsten Fabric](https://tungsten.io/)
,是一个开源的多云网络虚拟化和策略管理平台。 Contrail 和 Tungsten Fabric 与业务流程系统(例如 Kubernetes、OpenShift、OpenStack 和 Mesos)集成在一起, 为虚拟机、容器或 Pod 以及裸机工作负载提供了隔离模式。
* [Flannel](https://github.com/flannel-io/flannel#deploying-flannel-manually)
是一个可以用于 Kubernetes 的 overlay 网络提供者。
* [Gateway API](https://kubernetes.io/zh-cn/docs/concepts/services-networking/gateway/)
是一个由 [SIG Network](https://github.com/kubernetes/community/tree/master/sig-network)
社区管理的开源项目, 为服务网络建模提供一种富有表达力、可扩展和面向角色的 API。
* [Knitter](https://github.com/ZTE/Knitter/)
是在一个 Kubernetes Pod 中支持多个网络接口的插件。
* [Multus](https://github.com/k8snetworkplumbingwg/multus-cni)
是一个多插件, 可在 Kubernetes 中提供多种网络支持,以支持所有 CNI 插件(例如 Calico、Cilium、Contiv、Flannel), 而且包含了在 Kubernetes 中基于 SRIOV、DPDK、OVS-DPDK 和 VPP 的工作负载。
* [OVN-Kubernetes](https://github.com/ovn-org/ovn-kubernetes/)
是一个 Kubernetes 网络驱动, 基于 [OVN(Open Virtual Network)](https://github.com/ovn-org/ovn/)
实现,是从 Open vSwitch (OVS) 项目衍生出来的虚拟网络实现。OVN-Kubernetes 为 Kubernetes 提供基于覆盖网络的网络实现, 包括一个基于 OVS 实现的负载均衡器和网络策略。
* [Nodus](https://github.com/akraino-edge-stack/icn-nodus)
是一个基于 OVN 的 CNI 控制器插件, 提供基于云原生的服务功能链 (SFC)。
* [NSX-T](https://docs.vmware.com/en/VMware-NSX-T-Data-Center/index.html)
容器插件(NCP) 提供了 VMware NSX-T 与容器协调器(例如 Kubernetes)之间的集成,以及 NSX-T 与基于容器的 CaaS / PaaS 平台(例如关键容器服务(PKS)和 OpenShift)之间的集成。
* [Nuage](https://github.com/nuagenetworks/nuage-kubernetes/blob/v5.1.1-1/docs/kubernetes-1-installation.rst)
是一个 SDN 平台,可在 Kubernetes Pods 和非 Kubernetes 环境之间提供基于策略的联网,并具有可视化和安全监控。
* [Romana](https://github.com/romana)
是一个 Pod 网络的第三层解决方案,并支持 [NetworkPolicy](https://kubernetes.io/zh-cn/docs/concepts/services-networking/network-policies/)
API。
* [Spiderpool](https://github.com/spidernet-io/spiderpool)
为 Kubernetes 提供了下层网络和 RDMA 高速网络解决方案,兼容裸金属、虚拟机和公有云等运行环境。
* [Terway](https://github.com/AliyunContainerService/terway/)
是一套基于阿里云 VPC 和 ECS 网络产品的 CNI 插件,能够在阿里云环境中提供原生的 VPC 网络和网络策略支持。
* [Weave Net](https://github.com/rajch/weave#using-weave-on-kubernetes)
提供在网络分组两端参与工作的联网和网络策略,并且不需要额外的数据库。
服务发现
----
* [CoreDNS](https://coredns.io/)
是一种灵活的,可扩展的 DNS 服务器,可以 [安装](https://github.com/coredns/helm)
为集群内的 Pod 提供 DNS 服务。
可视化管理
-----
* [Dashboard](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
是一个 Kubernetes 的 Web 控制台界面。
* [Headlamp](https://headlamp.dev/)
是一个**可扩展的 Kubernetes 用户界面(UI)**, 既可以**以集群内方式部署**,也可以**作为桌面应用程序使用**。
基础设施
----
* [KubeVirt](https://kubevirt.io/user-guide/#/installation/installation)
是可以让 Kubernetes 运行虚拟机的 add-on。通常运行在裸机集群上。
* [节点问题检测器](https://github.com/kubernetes/node-problem-detector)
在 Linux 节点上运行, 并将系统问题报告为[事件](https://kubernetes.io/zh-cn/docs/reference/kubernetes-api/cluster-resources/event-v1/)
或[节点状况](https://kubernetes.io/zh-cn/docs/concepts/architecture/nodes/#condition)
。
插桩
--
* [kube-state-metrics](https://kubernetes.io/zh-cn/docs/concepts/cluster-administration/kube-state-metrics)
遗留 Add-on
---------
还有一些其它 add-on 归档在已废弃的 [cluster/addons](https://git.k8s.io/kubernetes/cluster/addons)
路径中。
维护完善的 add-on 应该被链接到这里。欢迎提出 PR!
反馈
--
此页是否对你有帮助?
是 否
感谢反馈。如果你有一个关于如何使用 Kubernetes 的具体问题需要答案,可以访问 [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. 如果需要,请在 [GitHub 仓库](https://www.github.com/kubernetes/website/)
上登记新的问题 [报告问题](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
或者 [提出改进建议](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
最后修改 January 13, 2026 at 9:26 AM PST: [\[zh-cn\] sync addons networking (9d93ad8005)](https://github.com/kubernetes/website/commit/9d93ad800542c244f49cd6e086f763534757aece)
本页面中的条目引用了第三方产品或项目,这些产品(项目)提供了 Kubernetes 所需的功能。Kubernetes 项目的开发人员不对这些第三方产品(项目)负责。请参阅[CNCF 网站指南](https://github.com/cncf/foundation/blob/main/policies-guidance/website-guidelines.md)
了解更多细节。
在提交更改建议,向本页添加新的第三方链接之前,你应该先阅读[内容指南。](https://kubernetes.io/zh-cn/docs/contribute/style/content-guide/#third-party-content)
---
# 使用 kubeconfig 文件组织集群访问 | Kubernetes
使用 kubeconfig 文件组织集群访问
======================
使用 kubeconfig 文件来组织有关集群、用户、命名空间和身份认证机制的信息。 `kubectl` 命令行工具使用 kubeconfig 文件来查找选择集群所需的信息,并与集群的 API 服务器进行通信。
#### 说明:
用于配置集群访问的文件称为 **kubeconfig 文件**。 这是引用到配置文件的通用方法,并不意味着有一个名为 `kubeconfig` 的文件。
#### 警告:
请务必仅使用来源可靠的 kubeconfig 文件。使用特制的 kubeconfig 文件可能会导致恶意代码执行或文件暴露。 如果必须使用不受信任的 kubeconfig 文件,请首先像检查 Shell 脚本一样仔细检查此文件。
默认情况下,`kubectl` 在 `$HOME/.kube` 目录下查找名为 `config` 的文件。 你可以通过设置 `KUBECONFIG` 环境变量或者设置 [`--kubeconfig`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl/)
参数来指定其他 kubeconfig 文件。
有关创建和指定 kubeconfig 文件的分步说明, 请参阅[配置对多集群的访问](https://kubernetes.io/zh-cn/docs/tasks/access-application-cluster/configure-access-multiple-clusters)
。
支持多集群、用户和身份认证机制
---------------
假设你有多个集群,并且你的用户和组件以多种方式进行身份认证。比如:
* 正在运行的 kubelet 可能使用证书在进行认证。
* 用户可能通过令牌进行认证。
* 管理员可能拥有多个证书集合提供给各用户。
使用 kubeconfig 文件,你可以组织集群、用户和命名空间。你还可以定义上下文,以便在集群和命名空间之间快速轻松地切换。
上下文(Context)
------------
通过 kubeconfig 文件中的 _context_ 元素,使用简便的名称来对访问参数进行分组。 每个 context 都有三个参数:cluster、namespace 和 user。 默认情况下,`kubectl` 命令行工具使用 **当前上下文** 中的参数与集群进行通信。
选择当前上下文:
kubectl config use-context
KUBECONFIG 环境变量
---------------
`KUBECONFIG` 环境变量包含一个 kubeconfig 文件列表。 对于 Linux 和 Mac,此列表以英文冒号分隔。对于 Windows,此列表以英文分号分隔。 `KUBECONFIG` 环境变量不是必需的。 如果 `KUBECONFIG` 环境变量不存在,`kubectl` 将使用默认的 kubeconfig 文件:`$HOME/.kube/config`。
如果 `KUBECONFIG` 环境变量存在,`kubectl` 将使用 `KUBECONFIG` 环境变量中列举的文件合并后的有效配置。
合并 kubeconfig 文件
----------------
要查看配置,输入以下命令:
kubectl config view
如前所述,输出可能来自单个 kubeconfig 文件,也可能是合并多个 kubeconfig 文件的结果。
以下是 `kubectl` 在合并 kubeconfig 文件时使用的规则。
1. 如果设置了 `--kubeconfig` 参数,则仅使用指定的文件。不进行合并。此参数只能使用一次。
否则,如果设置了 `KUBECONFIG` 环境变量,将它用作应合并的文件列表。根据以下规则合并 `KUBECONFIG` 环境变量中列出的文件:
* 忽略空文件名。
* 对于内容无法反序列化的文件,产生错误信息。
* 第一个设置特定值或者映射键的文件将生效。
* 永远不会更改值或者映射键。示例:保留第一个文件的上下文以设置 `current-context`。 示例:如果两个文件都指定了 `red-user`,则仅使用第一个文件的 `red-user` 中的值。 即使第二个文件在 `red-user` 下有非冲突条目,也要丢弃它们。
有关设置 `KUBECONFIG` 环境变量的示例, 请参阅[设置 KUBECONFIG 环境变量](https://kubernetes.io/zh-cn/docs/tasks/access-application-cluster/configure-access-multiple-clusters/#set-the-kubeconfig-environment-variable)
。
否则,使用默认的 kubeconfig 文件(`$HOME/.kube/config`),不进行合并。
2. 根据此链中的第一个匹配确定要使用的上下文。
1. 如果存在上下文,则使用 `--context` 命令行参数。
2. 使用合并的 kubeconfig 文件中的 `current-context`。
这种场景下允许空上下文。
3. 确定集群和用户。此时,可能有也可能没有上下文。根据此链中的第一个匹配确定集群和用户, 这将运行两次:一次用于用户,一次用于集群。
1. 如果存在用户或集群,则使用命令行参数:`--user` 或者 `--cluster`。
2. 如果上下文非空,则从上下文中获取用户或集群。
这种场景下用户和集群可以为空。
4. 确定要使用的实际集群信息。此时,可能有也可能没有集群信息。 基于此链构建每个集群信息;第一个匹配项会被采用:
1. 如果存在集群信息,则使用命令行参数:`--server`、`--certificate-authority` 和 `--insecure-skip-tls-verify`。
2. 如果合并的 kubeconfig 文件中存在集群信息属性,则使用这些属性。
3. 如果没有 server 配置,则配置无效。
5. 确定要使用的实际用户信息。使用与集群信息相同的规则构建用户信息,但对于每个用户只允许使用一种身份认证技术:
1. 如果存在用户信息,则使用命令行参数:`--client-certificate`、`--client-key`、`--username`、`--password` 和 `--token`。
2. 使用合并的 kubeconfig 文件中的 `user` 字段。
3. 如果存在两种冲突技术,则配置无效。
6. 对于仍然缺失的任何信息,使用其对应的默认值,并可能提示输入身份认证信息。
文件引用
----
kubeconfig 文件中的文件和路径引用是相对于 kubeconfig 文件的位置。 命令行上的文件引用是相对于当前工作目录的。 在 `$HOME/.kube/config` 中,相对路径按相对路径存储,而绝对路径按绝对路径存储。
代理
--
你可以在 `kubeconfig` 文件中,为每个集群配置 `proxy-url` 来让 `kubectl` 使用代理,例如:
apiVersion: v1
kind: Config
clusters:
- cluster:
proxy-url: http://proxy.example.org:3128
server: https://k8s.example.org/k8s/clusters/c-xxyyzz
name: development
users:
- name: developer
contexts:
- context:
name: development
接下来
---
* [配置对多集群的访问](https://kubernetes.io/zh-cn/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
* [`kubectl config`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#config)
反馈
--
此页是否对你有帮助?
是 否
感谢反馈。如果你有一个关于如何使用 Kubernetes 的具体问题需要答案,可以访问 [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. 如果需要,请在 [GitHub 仓库](https://www.github.com/kubernetes/website/)
上登记新的问题 [报告问题](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
或者 [提出改进建议](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
最后修改 March 07, 2023 at 6:06 PM PST: [\[zh\] sync organize-cluster-access-kubeconfig.md (bccd515e3e)](https://github.com/kubernetes/website/commit/bccd515e3ea8ecc79a06cb7ae71204085225baca)
---
# Kubernetes | Kubernetes
O Kubernetes é uma engine de orquestração de contêineres Open Source utilizado para automatizar a implantação, dimensionamento e gerenciamento de aplicativos em contêiner. O projeto é hospedado por the Cloud Native Computing Foundation ([CNCF](https://www.cncf.io/about)
).
Entenda o básico
----------------
Aprenda sobre o Kubernetes e seus conceitos fundamentais.
* [Visão Geral](https://kubernetes.io/pt-br/docs/concepts/overview/)
* [Componentes do Kubernetes](https://kubernetes.io/pt-br/docs/concepts/overview/components/)
* [Entendendo os objetos do Kubernetes](https://kubernetes.io/pt-br/docs/concepts/overview/working-with-objects/kubernetes-objects/)
Aprenda Conceitos
Experimente o Kubernetes
------------------------
Siga os tutoriais para aprender a implantar aplicativos no Kubernetes.
* [Olá, Minikube!](https://kubernetes.io/pt-br/docs/tutorials/hello-minikube/)
Veja os Tutoriais
Configurar um cluster
---------------------
Obtenha um Kubernetes em execução com base em seus recursos e necessidades.
* [Ambiente de aprendizagem](https://kubernetes.io/pt-br/docs/setup/#ambiente-de-aprendizagem)
* [Ambiente de produção](https://kubernetes.io/pt-br/docs/setup/#ambiente-de-produ%c3%a7%c3%a3o)
* [Instalar a ferramenta de configuração kubeadm](https://kubernetes.io/pt-br/docs/setup/production-environment/tools/kubeadm/install-kubeadm/)
Configurando um Kubernetes
Aprenda a usar o Kubernetes
---------------------------
Procure tarefas comuns e como realizá-las usando uma pequena seqüência de etapas.
* [Referência Rápida do kubectl](https://kubernetes.io/pt-br/docs/reference/kubectl/quick-reference/)
* [Instale o kubectl](https://kubernetes.io/pt-br/docs/tasks/tools/#kubectl)
* [Configure o acesso a clusters](https://kubernetes.io/pt-br/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
* [Use o Painel Web do Kubernetes](https://kubernetes.io/pt-br/docs/tasks/access-application-cluster/web-ui-dashboard/)
* [Configurando um Pod Para Usar um ConfigMap](https://kubernetes.io/pt-br/docs/tasks/configure-pod-container/configure-pod-configmap/)
* [Obtendo ajuda](https://kubernetes.io/pt-br/docs/tasks/debug/)
Visualizar tarefas
Procurar informações de referência
----------------------------------
Navegue pela terminologia, pela sintaxe da linha de comando, pelos tipos de recursos da API e pela documentação da ferramenta de configuração.
* [Glossário](https://kubernetes.io/pt-br/docs/reference/glossary/)
* [Ferramenta de linha de comando kubectl](https://kubernetes.io/pt-br/docs/reference/kubectl/)
* [kubectl Cheat Sheet](https://kubernetes.io/pt-br/docs/reference/kubectl/cheatsheet/)
* [Kubeadm](https://kubernetes.io/pt-br/docs/reference/setup-tools/kubeadm/)
Visualizar referência
Contribua para a documentação
-----------------------------
Qualquer um pode contribuir, quer você seja novo no projeto ou esteja há um bom tempo.
Contribua para a Documentação
Download Kubernetes
-------------------
Se você estiver instalando o Kubernetes ou atualizando para a versão mais recente, consulte as notas de versão atuais.
Sobre a documentação
--------------------
Este site contém documentação para a versão atual e as 4 versões anteriores do Kubernetes.
* [Versões Suportadas da Documentação](https://kubernetes.io/pt-br/docs/home/supported-doc-versions/)
---
# アドオンのインストール | Kubernetes
**このページに記載されている情報は古い可能性があります**
このページの更新日は英語版よりも古いため、記載されている情報が古い可能性があります。最新の情報をご覧になりたい方は英語版のページをご覧ください: [Installing Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
アドオンのインストール
===========
**備考:** このセクションでは、Kubernetesが必要とする機能を提供するサードパーティープロジェクトにリンクしています。これらのプロジェクトはアルファベット順に記載されていて、Kubernetesプロジェクトの作者は責任を持ちません。このリストにプロジェクトを追加するには、変更を提出する前に[content guide](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
をお読みください。[詳細はこちら。](https://kubernetes.io/ja/docs/concepts/cluster-administration/addons/#third-party-content-disclaimer)
アドオンはKubernetesの機能を拡張するものです。
このページでは、利用可能なアドオンの一部の一覧と、それぞれのアドオンのインストール方法へのリンクを提供します。 この一覧は、すべてを網羅するものではありません。
ネットワークとネットワークポリシー
-----------------
* [ACI](https://www.github.com/noironetworks/aci-containers)
は、統合されたコンテナネットワークとネットワークセキュリティをCisco ACIを使用して提供します。
* [Antrea](https://antrea.io/)
は、L3またはL4で動作して、Open vSwitchをネットワークデータプレーンとして活用する、Kubernetes向けのネットワークとセキュリティサービスを提供します。 Antreaは[SandboxレベルのCNCFプロジェクト](https://www.cncf.io/projects/antrea/)
です。
* [Calico](https://www.tigera.io/project-calico/)
は、ネットワーキングおよびネットワークポリシーのプロバイダーです。 Calicoは柔軟なネットワーキングオプションをサポートしており、BGPの有無を含む非オーバーレイネットワークやオーバーレイネットワークなど、状況に応じて最も効率的なオプションを選択できます。 Calicoは、ホスト、Pod、および(IstioとEnvoyを使用している場合)サービスメッシュレイヤーのアプリケーションに対して、同じエンジンを使用してネットワークポリシーを適用します。
* [Canal](https://projectcalico.docs.tigera.io/getting-started/kubernetes/flannel/flannel)
はFlannelとCalicoをあわせたもので、ネットワークとネットワークポリシーを提供します。
* [Cilium](https://github.com/cilium/cilium)
は、eBPFベースのデータプレーンを備えたネットワーク、可観測性、およびセキュリティのソリューションです。 Ciliumは、ネイティブなルーティングまたはoverlay/encapsulationモードのいずれかを用いて複数のクラスターにまたがることができる、シンプルでフラットなL3ネットワークを提供します。 また、ネットワークのアドレス指定から切り離されたアイデンティティベースのセキュリティモデルを使用して、L3からL7のネットワークポリシーを適用することができます。 Ciliumはkube-proxyの代替として機能し、オプトインにて可観測性およびセキュリティ機能も追加で提供しています。 Ciliumは[GraduatedレベルのCNCFプロジェクト](https://www.cncf.io/projects/cilium/)
です。
* [CNI-Genie](https://github.com/cni-genie/CNI-Genie)
は、KubernetesをCalico、Canal、Flannel、Weaveなど選択したCNIプラグインをシームレスに接続できるようにするプラグインです。 CNI-Genieは[SandboxレベルのCNCFプロジェクト](https://www.cncf.io/projects/cni-genie/)
です。
* [Contiv](https://contivpp.io/)
は、さまざまなユースケースと豊富なポリシーフレームワーク向けに設定可能なネットワーク(BGPを使用したネイティブのL3、vxlanを使用したオーバーレイ、古典的なL2、Cisco-SDN/ACI)を提供します。 Contivプロジェクトは完全に[オープンソース](https://github.com/contiv)
です。 [インストーラー](https://github.com/contiv/install)
はkubeadmとkubeadm以外の両方をベースとしたインストールオプションがあります。
* [Contrail](https://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
は、[Tungsten Fabric](https://tungsten.io/)
をベースにしている、オープンソースでマルチクラウドに対応したネットワーク仮想化およびポリシー管理プラットフォームです。 ContrailおよびTungsten Fabricは、Kubernetes、OpenShift、OpenStack、Mesosなどのオーケストレーションシステムと統合されており、仮想マシン、コンテナ/Pod、ベアメタルのワークロードに隔離モードを提供します。
* [Flannel](https://github.com/flannel-io/flannel#deploying-flannel-manually)
は、Kubernetesで使用できるオーバーレイネットワークプロバイダーです。
* [Gateway API](https://kubernetes.io/ja/docs/concepts/services-networking/gateway/)
は、[SIG Network](https://github.com/kubernetes/community/tree/master/sig-network)
コミュニティによって管理されているオープンソースプロジェクトで、サービスネットワーキングをモデル化するための表現力豊かで拡張可能、かつロール指向のAPIを提供します。
* [Knitter](https://github.com/ZTE/Knitter/)
は、1つのKubernetes Podで複数のネットワークインターフェースをサポートするためのプラグインです。
* [Multus](https://github.com/k8snetworkplumbingwg/multus-cni)
は、すべてのCNIプラグイン(たとえば、Calico、Cilium、Contiv、Flannel)に加えて、SRIOV、DPDK、OVS-DPDK、VPPをベースとするKubernetes上のワークロードをサポートする、複数のネットワークサポートのためのマルチプラグインです。
* [OVN-Kubernetes](https://github.com/ovn-org/ovn-kubernetes/)
は、Open vSwitch(OVS)プロジェクトから生まれた仮想ネットワーク実装である[OVN(Open Virtual Network)](https://github.com/ovn-org/ovn/)
をベースとする、Kubernetesのためのネットワークプロバイダーです。 OVN-Kubernetesは、OVSベースのロードバランサーおよびネットワークポリシーの実装を含む、Kubernetes向けのオーバーレイベースのネットワーク実装を提供します。
* [Nodus](https://github.com/akraino-edge-stack/icn-nodus)
は、OVNベースのCNIコントローラープラグインで、クラウドネイティブベースのService function chaining(SFC)を提供します。
* [NSX-T](https://docs.vmware.com/en/VMware-NSX-T-Data-Center/index.html)
Container Plug-in(NCP)は、VMware NSX-TとKubernetesなどのコンテナオーケストレーター間のインテグレーションを提供します。 また、NSX-Tと、Pivotal Container Service(PKS)とOpenShiftなどのコンテナベースのCaaS/PaaSプラットフォームとのインテグレーションも提供します。
* [Nuage](https://github.com/nuagenetworks/nuage-kubernetes/blob/v5.1.1-1/docs/kubernetes-1-installation.rst)
は、Kubernetes Podと非Kubernetes環境間で可視化とセキュリティモニタリングを使用してポリシーベースのネットワークを提供するSDNプラットフォームです。
* [Romana](https://github.com/romana)
は、[NetworkPolicy](https://kubernetes.io/ja/docs/concepts/services-networking/network-policies/)
APIもサポートするPodネットワーク向けのL3のネットワークソリューションです。
* [Spiderpool](https://github.com/spidernet-io/spiderpool)
は、Kubernetes向けのアンダーレイおよびRDMAネットワークソリューションです。 Spiderpoolは、ベアメタル、仮想マシン、パブリッククラウド環境でサポートされています。
* [Terway](https://github.com/AliyunContainerService/terway/)
は、AlibabaCloudのVPCおよびECSネットワーク製品をベースとしたCNIプラグインの一式です。 AlibabaCloud環境でネイティブVPCネットワーキングとネットワークポリシーを提供します。
* [Weave Net](https://github.com/rajch/weave#using-weave-on-kubernetes)
は、ネットワークパーティションの両面で機能し、外部データベースを必要とせずに、ネットワークとネットワークポリシーを提供します。
サービスディスカバリ
----------
* [CoreDNS](https://coredns.io/)
は、フレキシブルで拡張可能なDNSサーバーです。 Pod向けのクラスター内DNSとして[インストール](https://github.com/coredns/helm)
できます。
可視化と制御
------
* [Dashboard](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
はKubernetes向けのダッシュボードを提供するウェブインターフェースです。
* [Headlamp](https://headlamp.dev/)
は、拡張可能なKubernetesのUIです。 クラスター内にデプロイすることや、デスクトップアプリケーションとして使用することができます。
インフラストラクチャ
----------
* [KubeVirt](https://kubevirt.io/user-guide/#/installation/installation)
は仮想マシンをKubernetes上で実行するためのアドオンです。 通常、ベアメタルのクラスターで実行します。
* [node problem detector](https://github.com/kubernetes/node-problem-detector)
はLinuxノード上で動作し、システムの問題を[Event](https://kubernetes.io/docs/reference/kubernetes-api/cluster-resources/event-v1/)
または[ノードのCondition](https://kubernetes.io/ja/docs/concepts/architecture/nodes/#condition)
として報告します。
計測
--
* [kube-state-metrics](https://kubernetes.io/ja/docs/concepts/cluster-administration/kube-state-metrics/)
レガシーなアドオン
---------
いくつかのアドオンは、廃止された[cluster/addons](https://git.k8s.io/kubernetes/cluster/addons)
ディレクトリに掲載されています。
よくメンテナンスされたアドオンはここにリンクしてください。 PRを歓迎しています。
フィードバック
-------
このページは役に立ちましたか?
はい いいえ
Thanks for the feedback. If you have a specific, answerable question about how to use Kubernetes, ask it on [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. Open an issue in the GitHub repo if you want to [問題を報告する](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
or [改善を提案](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
最終更新 February 09, 2026 at 12:47 AM PST: [\[ja\] Update content/ja/docs/concepts/cluster-administration/addons.md (#53946) (4385f8eed9)](https://github.com/kubernetes/website/commit/4385f8eed90fe6016ec370f7d8d1fe0e5e6af6a7)
このページの項目は、Kubernetesが必要とする機能を提供するサードパーティー製品またはプロジェクトです。Kubernetesプロジェクトの作者は、それらのサードパーティー製品またはプロジェクトに責任を負いません。詳しくは、[CNCFウェブサイトのガイドライン](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
をご覧ください。第三者のリンクを追加するような変更を提案する前に、[コンテンツガイド](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
を読むべきです。
---
# kubeconfigファイルを使用してクラスターアクセスを組織する | Kubernetes
kubeconfigファイルを使用してクラスターアクセスを組織する
=================================
kubeconfigを使用すると、クラスターに、ユーザー、名前空間、認証の仕組みに関する情報を組織できます。`kubectl`コマンドラインツールはkubeconfigファイルを使用してクラスターを選択するために必要な情報を見つけ、クラスターのAPIサーバーと通信します。
#### 備考:
クラスターへのアクセスを設定するために使われるファイルは_kubeconfigファイル_と呼ばれます。これは設定ファイルを指すために使われる一般的な方法です。`kubeconfig`という名前を持つファイルが存在するという意味ではありません。
#### 警告:
信頼できるソースからのkubeconfigファイルのみを使用してください。特別に細工されたkubeconfigファイルを使用すると、悪意のあるコードの実行やファイルの公開につながる可能性があります。 信頼できないkubeconfigファイルを使用しなければならない場合は、シェルスクリプトを使用するのと同じように、まず最初に慎重に検査してください。
デフォルトでは、`kubectl`は`$HOME/.kube`ディレクトリ内にある`config`という名前のファイルを探します。`KUBECONFIG`環境変数を設定するか、[`--kubeconfig`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl/)
フラグで指定することで、別のkubeconfigファイルを指定することもできます。
kubeconfigファイルの作成と指定に関するステップバイステップの手順を知りたいときは、[複数のクラスターへのアクセスを設定する](https://kubernetes.io/ja/docs/tasks/access-application-cluster/configure-access-multiple-clusters)
を参照してください。
複数のクラスター、ユーザ、認証の仕組みのサポート
------------------------
複数のクラスターを持っていて、ユーザーやコンポーネントがさまざまな方法で認証を行う次のような状況を考えてみます。
* 実行中のkubeletが証明書を使用して認証を行う可能性がある。
* ユーザーがトークンを使用して認証を行う可能性がある。
* 管理者が個別のユーザに提供する複数の証明書を持っている可能性がある。
kubeconfigファイルを使用すると、クラスター、ユーザー、名前空間を組織化することができます。また、contextを定義することで、複数のクラスターや名前空間を素早く簡単に切り替えられます。
Context
-------
kubeconfigファイルの_context_要素は、アクセスパラメーターを使いやすい名前でグループ化するために使われます。各contextは3つのパラメーター、cluster、namespace、userを持ちます。デフォルトでは、`kubectl`コマンドラインツールはクラスターとの通信に_current context_のパラメーターを使用します。
current contextを選択するには、以下のコマンドを使用します。
kubectl config use-context
KUBECONFIG環境変数
--------------
`KUBECONFIG`環境変数には、kubeconfigファイルのリストを指定できます。LinuxとMacでは、リストはコロン区切りです。Windowsでは、セミコロン区切りです。`KUBECONFIG`環境変数は必須ではありません。`KUBECONFIG`環境変数が存在しない場合は、`kubectl`はデフォルトのkubeconfigファイルである`$HOME/.kube/config`を使用します。
`KUBECONFIG`環境変数が存在する場合は、`kubectl`は`KUBECONFIG`環境変数にリストされているファイルをマージした結果を有効な設定として使用します。
kubeconfigファイルのマージ
------------------
設定ファイルを確認するには、以下のコマンドを実行します。
kubectl config view
上で説明したように、出力は1つのkubeconfigファイルから作られる場合も、複数のkubeconfigファイルをマージした結果となる場合もあります。
`kubectl`がkubeconfigファイルをマージするときに使用するルールを以下に示します。
1. もし`--kubeconfig`フラグが設定されていた場合、指定したファイルだけが使用されます。マージは行いません。このフラグに指定できるのは1つのファイルだけです。
そうでない場合、`KUBECONFIG`環境変数が設定されていた場合には、それをマージするべきファイルのリストとして使用します。`KUBECONFIG`環境変数にリストされたファイルのマージは、次のようなルールに従って行われます。
* 空のファイルを無視する。
* デシリアライズできない内容のファイルに対してエラーを出す。
* 特定の値やmapのキーを設定する最初のファイルが勝つ。
* 値やmapのキーは決して変更しない。 例: 最初のファイルが指定した`current-context`を保持する。 例: 2つのファイルが`red-user`を指定した場合、1つ目のファイルの`red-user`だけを使用する。もし2つ目のファイルの`red-user`以下に競合しないエントリーがあったとしても、それらは破棄する。
`KUBECONFIG`環境変数を設定する例については、[KUBECONFIG環境変数を設定する](https://kubernetes.io/ja/docs/tasks/access-application-cluster/configure-access-multiple-clusters/#set-the-kubeconfig-environment-variable)
を参照してください。
それ以外の場合は、デフォルトのkubeconfigファイル`$HOME/.kube/config`をマージせずに使用します。
2. 以下のチェーンで最初に見つかったものをもとにして、使用するcontextを決定する。
1. `--context`コマンドラインフラグが存在すれば、それを使用する。
2. マージしたkubeconrfigファイルから`current-context`を使用する。
この時点では、空のcontextも許容されます。
3. クラスターとユーザーを決定する。この時点では、contextである場合もそうでない場合もあります。以下のチェーンで最初に見つかったものをもとにして、クラスターとユーザーを決定します。この手順はユーザーとクラスターについてそれぞれ1回ずつ、合わせて2回実行されます。
1. もし存在すれば、コマンドラインフラグ`--user`または`--cluster`を使用する。
2. もしcontextが空でなければ、contextからユーザーまたはクラスターを取得する。
この時点では、ユーザーとクラスターは空である可能性があります。
4. 使用する実際のクラスター情報を決定する。この時点では、クラスター情報は存在しない可能性があります。以下のチェーンで最初に見つかったものをもとにして、クラスター情報の各パーツをそれぞれを構築します。
1. もし存在すれば、`--server`、`--certificate-authority`、`--insecure-skip-tls-verify`コマンドラインフラグを使用する。
2. もしマージしたkubeconfigファイルにクラスター情報の属性が存在すれば、それを使用する。
3. もしサーバーの場所が存在しなければ、マージは失敗する。
5. 使用する実際のユーザー情報を決定する。クラスター情報の場合と同じルールを使用して、ユーザー情報を構築します。ただし、ユーザーごとに許可される認証方法は1つだけです。
1. もし存在すれば、`--client-certificate`、`--client-key`、`--username`、`--password`、`--token`コマンドラインフラグを使用する。
2. マージしたkubeconfigファイルの`user`フィールドを使用する。
3. もし2つの競合する方法が存在する場合、マージは失敗する。
6. もし何らかの情報がまだ不足していれば、デフォルトの値を使用し、認証情報については場合によってはプロンプトを表示する。
ファイルリファレンス
----------
kubeconfigファイル内のファイルとパスのリファレンスは、kubeconfigファイルの位置からの相対パスで指定します。コマンドライン上のファイルのリファレンスは、現在のワーキングディレクトリからの相対パスです。`$HOME/.kube/config`内では、相対パスは相対のまま、絶対パスは絶対のまま保存されます。
プロキシ
----
kubeconfigファイルで`proxy-url`を使用すると、以下のようにクラスターごとにプロキシを使用するように`kubectl`を設定することができます。
apiVersion: v1
kind: Config
clusters:
- cluster:
proxy-url: http://proxy.example.org:3128
server: https://k8s.example.org/k8s/clusters/c-xxyyzz
name: development
users:
- name: developer
contexts:
- context:
name: development
次の項目
----
* [複数のクラスターへのアクセスを設定する](https://kubernetes.io/ja/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
* [`kubectl config`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#config)
フィードバック
-------
このページは役に立ちましたか?
はい いいえ
Thanks for the feedback. If you have a specific, answerable question about how to use Kubernetes, ask it on [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. Open an issue in the GitHub repo if you want to [問題を報告する](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
or [改善を提案](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
最終更新 February 06, 2024 at 4:27 PM PST: [\[ja\] fix term "proxy" variations (adada78799)](https://github.com/kubernetes/website/commit/adada78799d09303426a8761fc05d2b43d55f98a)
---
# 애드온 설치 | Kubernetes
**Information in this document may be out of date**
This document has an older update date than the original, so the information it contains may be out of date. If you're able to read English, see the English version for the most up-to-date information: [Installing Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
애드온 설치
======
**참고:** 이 섹션은 쿠버네티스에 필요한 기능을 제공하는 써드파티 프로젝트와 관련이 있다. 쿠버네티스 프로젝트 작성자는 써드파티 프로젝트에 책임이 없다. 이 페이지는 [CNCF 웹사이트 가이드라인](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
에 따라 프로젝트를 알파벳 순으로 나열한다. 이 목록에 프로젝트를 추가하려면 변경사항을 제출하기 전에 [콘텐츠 가이드](https://kubernetes.io/contribute/style/content-guide/#third-party-content)
를 읽어본다.
애드온은 쿠버네티스의 기능을 확장한다.
이 페이지는 사용 가능한 일부 애드온과 관련 설치 지침 링크를 나열한다. 이 목차에서 전체를 다루지는 않는다.
네트워킹과 네트워크 폴리시
--------------
* [ACI](https://www.github.com/noironetworks/aci-containers)
는 Cisco ACI로 통합 컨테이너 네트워킹 및 네트워크 보안을 제공한다.
* [Antrea](https://antrea.io/)
는 레이어 3/4에서 작동하여 쿠버네티스를 위한 네트워킹 및 보안 서비스를 제공하며, Open vSwitch를 네트워킹 데이터 플레인으로 활용한다.
* [Calico](https://docs.projectcalico.org/latest/introduction/)
는 네트워킹 및 네트워크 폴리시 제공자이다. Calico는 유연한 네트워킹 옵션을 지원하므로 BGP 유무에 관계없이 비-오버레이 및 오버레이 네트워크를 포함하여 가장 상황에 맞는 옵션을 선택할 수 있다. Calico는 동일한 엔진을 사용하여 서비스 메시 계층(service mesh layer)에서 호스트, 파드 및 (이스티오(istio)와 Envoy를 사용하는 경우) 애플리케이션에 대한 네트워크 폴리시를 적용한다.
* [Canal](https://projectcalico.docs.tigera.io/getting-started/kubernetes/flannel/flannel)
은 Flannel과 Calico를 통합하여 네트워킹 및 네트워크 폴리시를 제공한다.
* [Cilium](https://github.com/cilium/cilium)
은 네트워킹, 관측 용의성(Observability), 보안 특징을 지닌 eBPF 기반 데이터 플레인을 갖춘 솔루션입니다. Cilium은 기본 라우팅 및 오버레이/캡슐화 모드를 모두 지원하며, 여러 클러스터를 포괄할 수 있는 단순한 플랫(flat) Layer 3 네트워크를 제공합니다. 또한, Cilium은 (네트워크 주소 지정 방식에서 분리된) 신원 기반 보안 모델(identity-based security model)을 사용하여 L3-L7에서 네트워크 정책을 시행할 수 있습니다. Cilium은 kube-proxy를 대체하는 역할을 할 수 있습니다. 또한 부가적으로, 옵트인(opt-in) 형태로 관측 용의성(Observability) 및 보안 기능을 제공합니다.
* [CNI-Genie](https://github.com/cni-genie/CNI-Genie)
를 사용하면 쿠버네티스는 Calico, Canal, Flannel, Romana 또는 Weave와 같은 CNI 플러그인을 완벽하게 연결할 수 있다.
* [Contiv](https://contivpp.io/)
는 다양한 유스케이스와 풍부한 폴리시 프레임워크를 위해 구성 가능한 네트워킹(BGP를 사용하는 네이티브 L3, vxlan을 사용하는 오버레이, 클래식 L2 그리고 Cisco-SDN/ACI)을 제공한다. Contiv 프로젝트는 완전히 [오픈소스](https://github.com/contiv)
이다. [인스톨러](https://github.com/contiv/install)
는 kubeadm을 이용하거나, 그렇지 않은 경우에 대해서도 설치 옵션을 모두 제공한다.
* [Contrail](https://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
은 [Tungsten Fabric](https://tungsten.io/)
을 기반으로 하며, 오픈소스이고, 멀티 클라우드 네트워크 가상화 및 폴리시 관리 플랫폼이다. Contrail과 Tungsten Fabric은 쿠버네티스, OpenShift, OpenStack 및 Mesos와 같은 오케스트레이션 시스템과 통합되어 있으며, 가상 머신, 컨테이너/파드 및 베어 메탈 워크로드에 대한 격리 모드를 제공한다.
* [Flannel](https://github.com/flannel-io/flannel#deploying-flannel-manually)
은 쿠버네티스와 함께 사용할 수 있는 오버레이 네트워크 제공자이다.
* [Knitter](https://github.com/ZTE/Knitter/)
는 쿠버네티스 파드에서 여러 네트워크 인터페이스를 지원하는 플러그인이다.
* [Multus](https://github.com/k8snetworkplumbingwg/multus-cni)
는 쿠버네티스의 다중 네트워크 지원을 위한 멀티 플러그인이며, 모든 CNI 플러그인(예: Calico, Cilium, Contiv, Flannel)과 쿠버네티스 상의 SRIOV, DPDK, OVS-DPDK 및 VPP 기반 워크로드를 지원한다.
* [OVN-Kubernetes](https://github.com/ovn-org/ovn-kubernetes/)
는 Open vSwitch(OVS) 프로젝트에서 나온 가상 네트워킹 구현인 [OVN(Open Virtual Network)](https://github.com/ovn-org/ovn/)
을 기반으로 하는 쿠버네티스용 네트워킹 제공자이다. OVN-Kubernetes는 OVS 기반 로드 밸런싱과 네트워크 폴리시 구현을 포함하여 쿠버네티스용 오버레이 기반 네트워킹 구현을 제공한다.
* [Nodus](https://github.com/akraino-edge-stack/icn-nodus)
는 클라우드 네이티브 기반 서비스 기능 체인(SFC)을 제공하는 OVN 기반 CNI 컨트롤러 플러그인이다.
* [NSX-T](https://docs.vmware.com/en/VMware-NSX-T-Data-Center/index.html)
컨테이너 플러그인(NCP)은 VMware NSX-T와 쿠버네티스와 같은 컨테이너 오케스트레이터 간의 통합은 물론 NSX-T와 PKS(Pivotal 컨테이너 서비스) 및 OpenShift와 같은 컨테이너 기반 CaaS/PaaS 플랫폼 간의 통합을 제공한다.
* [Nuage](https://github.com/nuagenetworks/nuage-kubernetes/blob/v5.1.1-1/docs/kubernetes-1-installation.rst)
는 가시성과 보안 모니터링 기능을 통해 쿠버네티스 파드와 비-쿠버네티스 환경 간에 폴리시 기반 네트워킹을 제공하는 SDN 플랫폼이다.
* [Romana](https://github.com/romana)
는 [네트워크폴리시 API](https://kubernetes.io/ko/docs/concepts/services-networking/network-policies/)
도 지원하는 파드 네트워크용 Layer 3 네트워킹 솔루션이다.
* [Weave Net](https://github.com/rajch/weave#using-weave-on-kubernetes)
은 네트워킹 및 네트워크 폴리시를 제공하고, 네트워크 파티션의 양면에서 작업을 수행하며, 외부 데이터베이스는 필요하지 않다.
서비스 검색
------
* [CoreDNS](https://coredns.io/)
는 유연하고 확장 가능한 DNS 서버로, 파드를 위한 클러스터 내 DNS로 [설치](https://github.com/coredns/helm)
할 수 있다.
시각화 & 제어
--------
* [대시보드](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
는 쿠버네티스를 위한 대시보드 웹 인터페이스이다.
인프라스트럭처
-------
* [KubeVirt](https://kubevirt.io/user-guide/#/installation/installation)
는 쿠버네티스에서 가상 머신을 실행하기 위한 애드온이다. 일반적으로 베어 메탈 클러스터에서 실행한다.
* [node problem detector](https://github.com/kubernetes/node-problem-detector)
는 리눅스 노드에서 실행되며, 시스템 이슈를 [이벤트](https://kubernetes.io/docs/reference/kubernetes-api/cluster-resources/event-v1/)
또는 [노드 컨디션](https://kubernetes.io/ko/docs/concepts/architecture/nodes/#condition)
형태로 보고한다.
레거시 애드온
-------
더 이상 사용되지 않는 [cluster/addons](https://git.k8s.io/kubernetes/cluster/addons)
디렉터리에 다른 여러 애드온이 문서화되어 있다.
잘 관리된 것들이 여기에 연결되어 있어야 한다. PR을 환영한다!
피드백
---
이 페이지가 도움이 되었나요?
네 아니요
피드백 감사합니다. 쿠버네티스 사용 방법에 대해서 구체적이고 답변 가능한 질문이 있다면, 다음 링크에서 질문하십시오. [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. 원한다면 GitHub 리포지터리에 이슈를 열어서 [문제 리포트](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
또는 [개선 제안이 가능합니다.](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
최종 수정 February 11, 2025 at 12:10 AM PST: [\[ko\] Fixed link for core dns helm charts (e24debf813)](https://github.com/kubernetes/website/commit/e24debf813c4fc953e89199e79917cba1eb86b39)
이 페이지는 쿠버네티스가 필요로 하는 기능을 제공하는 써드파티 프로젝트 또는 제품에 대해 언급하고 있습니다. 쿠버네티스 프로젝트 저자들은 이러한 써드파티 프로젝트 또는 제품에 대해 책임지지 않습니다. [CNCF 웹사이트 가이드라인](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
에서 더 자세한 내용을 확인합니다.
다른 써드파티 링크를 추가하는 변경을 제안하기 전에, [컨텐츠 가이드](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
를 확인해야 합니다.
---
# kubeconfig 파일을 사용하여 클러스터 접근 구성하기 | Kubernetes
kubeconfig 파일을 사용하여 클러스터 접근 구성하기
================================
kubeconfig 파일들을 사용하여 클러스터, 사용자, 네임스페이스 및 인증 메커니즘에 대한 정보를 관리하자. `kubectl` 커맨드라인 툴은 kubeconfig 파일을 사용하여 클러스터의 선택과 클러스터의 API 서버와의 통신에 필요한 정보를 찾는다.
#### 참고:
클러스터에 대한 접근을 구성하는 데 사용되는 파일을 _kubeconfig 파일_ 이라 한다. 이는 구성 파일을 참조하는 일반적인 방법을 의미한다. `kubeconfig`라는 이름의 파일이 있다는 의미는 아니다.
#### 경고:
신뢰할 수 있는 소스의 kubeconfig 파일만 사용한다. 특수 제작된 kubeconfig 파일을 사용하면 악성 코드가 실행되거나 파일이 노출될 수 있다. 신뢰할 수 없는 kubeconfig 파일을 사용해야 하는 경우 셸 스크립트를 사용하는 경우처럼 먼저 신중하게 검사한다.
기본적으로 `kubectl`은 `$HOME/.kube` 디렉터리에서 `config`라는 이름의 파일을 찾는다. `KUBECONFIG` 환경 변수를 설정하거나 [`--kubeconfig`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl/)
플래그를 지정해서 다른 kubeconfig 파일을 사용할 수 있다.
kubeconfig 파일을 생성하고 지정하는 단계별 지시사항은 [다중 클러스터로 접근 구성하기](https://kubernetes.io/ko/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
를 참조한다.
다중 클러스터, 사용자와 인증 메커니즘 지원
------------------------
여러 클러스터가 있고, 사용자와 구성 요소가 다양한 방식으로 인증한다고 가정하자. 예를 들면 다음과 같다.
* 실행 중인 kubelet은 인증서를 이용하여 인증할 수 있다.
* 사용자는 토큰으로 인증할 수 있다.
* 관리자는 개별 사용자에게 제공하는 인증서 집합을 가지고 있다.
kubeconfig 파일을 사용하면 클러스터와 사용자와 네임스페이스를 구성할 수 있다. 또한 컨텍스트를 정의하여 빠르고 쉽게 클러스터와 네임스페이스 간에 전환할 수 있다.
컨텍스트
----
kubeconfig에서 _컨텍스트_ 요소는 편리한 이름으로 접속 매개 변수를 묶는데 사용한다. 각 컨텍스트는 클러스터, 네임스페이스와 사용자라는 세 가지 매개 변수를 가진다. 기본적으로 `kubectl` 커맨드라인 툴은 _현재 컨텍스트_ 의 매개 변수를 사용하여 클러스터와 통신한다.
현재 컨택스트를 선택하려면 다음을 실행한다.
kubectl config use-context
KUBECONFIG 환경 변수
----------------
`KUBECONFIG` 환경 변수는 kubeconfig 파일 목록을 보유한다. 리눅스 및 Mac의 경우 이는 콜론(:)으로 구분된 목록이다. 윈도우는 세미콜론(;)으로 구분한다. `KUBECONFIG` 환경 변수가 필수는 아니다. `KUBECONFIG` 환경 변수가 없으면, `kubectl`은 기본 kubeconfig 파일인 `$HOME/.kube/config`를 사용한다.
`KUBECONFIG` 환경 변수가 존재하면, `kubectl`은 `KUBECONFIG` 환경 변수에 나열된 파일을 병합한 결과 형태의 효과적 구성을 이용한다.
kubeconfig 파일 병합
----------------
구성을 보려면, 다음 커맨드를 입력한다.
kubectl config view
앞서 설명한 것처럼, 이 출력 내용은 단일 kubeconfig 파일이나 여러 kubeconfig 파일을 병합한 결과 일 수 있다.
다음은 kubeconfig 파일을 병합할 때에 `kubectl`에서 사용하는 규칙이다.
1. `--kubeconfig` 플래그를 설정했으면, 지정한 파일만 사용한다. 병합하지 않는다. 이 플래그는 오직 한 개 인스턴스만 허용한다.
그렇지 않고, `KUBECONFIG` 환경 변수를 설정하였다면 병합해야 하는 파일의 목록으로 사용한다. `KUBECONFIG` 환경 변수의 나열된 파일은 다음 규칙에 따라 병합한다.
* 빈 파일명은 무시한다.
* 역 직렬화 불가한 파일 내용에 대해서 오류를 일으킨다.
* 특정 값이나 맵 키를 설정한 첫 번째 파일을 우선한다.
* 값이나 맵 키를 변경하지 않는다. 예: `현재 컨텍스트`를 설정할 첫 번째 파일의 컨택스트를 유지한다. 예: 두 파일이 `red-user`를 지정했다면, 첫 번째 파일의 `red-user` 값만을 사용한다. 두 번째 파일의 `red-user` 하위에 충돌하지 않는 항목이 있어도 버린다.
`KUBECONFIG` 환경 변수 설정의 예로, [KUBECONFIG 환경 변수 설정](https://kubernetes.io/ko/docs/tasks/access-application-cluster/configure-access-multiple-clusters/#kubeconfig-%ED%99%98%EA%B2%BD-%EB%B3%80%EC%88%98-%EC%84%A4%EC%A0%95)
를 참조한다.
그렇지 않다면, 병합하지 않고 기본 kubeconfig 파일인 `$HOME/.kube/config`를 사용한다.
2. 이 체인에서 첫 번째를 기반으로 사용할 컨텍스트를 결정한다.
1. 커맨드라인 플래그의 `--context`를 사용한다.
2. 병합된 kubeconfig 파일에서 `current-context`를 사용한다.
이 시점에서는 빈 컨텍스트도 허용한다.
3. 클러스터와 사용자를 결정한다. 이 시점에서는 컨텍스트가 있을 수도 있고 없을 수도 있다. 사용자에 대해 한 번, 클러스터에 대해 한 번 총 두 번에 걸친 이 체인에서 첫 번째 것을 기반으로 클러스터와 사용자를 결정한다.
1. 커맨드라인 플래그가 존재하면, `--user` 또는 `--cluster`를 사용한다.
2. 컨텍스트가 비어있지 않다면, 컨텍스트에서 사용자 또는 클러스터를 가져온다.
이 시점에서는 사용자와 클러스터는 비워둘 수 있다.
4. 사용할 실제 클러스터 정보를 결정한다. 이 시점에서 클러스터 정보가 있을 수 있고 없을 수도 있다. 이 체인을 기반으로 클러스터 정보를 구축한다. 첫 번째 것을 사용한다.
1. 커맨드라인 플래그가 존재하면, `--server`, `--certificate-authority`, `--insecure-skip-tls-verify`를 사용한다.
2. 병합된 kubeconfig 파일에서 클러스터 정보 속성이 있다면 사용한다.
3. 서버 위치가 없다면 실패한다.
5. 사용할 실제 사용자 정보를 결정한다. 사용자 당 하나의 인증 기법만 허용하는 것을 제외하고는 클러스터 정보와 동일한 규칙을 사용하여 사용자 정보를 작성한다.
1. 커맨드라인 플래그가 존재하면, `--client-certificate`, `--client-key`, `--username`, `--password`, `--token`을 사용한다.
2. 병합된 kubeconfig 파일에서 `user` 필드를 사용한다.
3. 충돌하는 두 가지 기법이 있다면 실패한다.
6. 여전히 누락된 정보는 기본 값을 사용하고 인증 정보를 묻는 메시지가 표시될 수 있다.
파일 참조
-----
kubeconfig 파일에서 파일과 경로 참조는 kubeconfig 파일의 위치와 관련 있다. 커맨드라인 상에 파일 참조는 현재 디렉터리를 기준으로 한다. `$HOME/.kube/config`에서 상대 경로는 상대적으로, 절대 경로는 절대적으로 저장한다.
프록시
---
다음과 같이 kubeconfig 파일에서 `proxy-url`를 사용하여 `kubectl`이 각 클러스터마다 프록시를 거치도록 설정할 수 있다.
apiVersion: v1
kind: Config
clusters:
- cluster:
proxy-url: http://proxy.example.org:3128
server: https://k8s.example.org/k8s/clusters/c-xxyyzz
name: development
users:
- name: developer
contexts:
- context:
name: development
다음 내용
-----
* [다중 클러스터 접근 구성하기](https://kubernetes.io/ko/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
* [`kubectl config`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#config)
피드백
---
이 페이지가 도움이 되었나요?
네 아니요
피드백 감사합니다. 쿠버네티스 사용 방법에 대해서 구체적이고 답변 가능한 질문이 있다면, 다음 링크에서 질문하십시오. [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. 원한다면 GitHub 리포지터리에 이슈를 열어서 [문제 리포트](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
또는 [개선 제안이 가능합니다.](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
최종 수정 July 20, 2022 at 1:05 AM PST: [Update outdated files dev-1.24-ko.2 (M11-M20) (4d92fef330)](https://github.com/kubernetes/website/commit/4d92fef330099bc888cdd0a8b22ab41dc5d7e614)
---
# Configurazione | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/concepts/configuration/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/concepts/configuration/)
.
Configurazione
==============
Risorse che fornisce Kubernetes per configurare i Pods.
* 1: [ConfigMaps](https://kubernetes.io/it/docs/concepts/configuration/_print/#pg-6b5ccadd699df0904e8e9917c5450c4b)
1 - ConfigMaps
==============
La ConfigMap è un oggetto API usato per memorizzare dati non riservati in coppie chiave-valore. I [Pods](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
possono utilizzare le ConfigMaps come variabili d'ambiente, argomenti da riga di comando, o come files di configurazione all'interno di un [Volume](https://kubernetes.io/it/docs/concepts/storage/volumes/ "Una cartella contenente dati, accessibile dai containers all'interno del pod.")
.
La ConfigMap ti permette di disaccoppiare le configurazioni specifiche per ambiente dalle [immagini del container](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-image "Istanza archiviata di un cointainer che contiene un insieme di software e librerie necessarie per eseguire l'applicazione.")
, cosicchè le tue applicazioni siano facilmente portabili.
#### Attenzione:
La ConfigMap non fornisce riservatezza o cifratura dei dati. Se i dati che vuoi salvare sono confidenziali, usa un [Secret](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-secret "Contiene informazioni sensibili, come passwords, token OAuth, e chiavi ssh.")
piuttosto che una ConfigMap, o usa uno strumento di terze parti per tenere privati i tuoi dati.
Utilizzo
--------
Usa una ConfigMap per tenere separati i dati di configurazione dal codice applicativo.
Per esempio, immagina che stai sviluppando un'applicazione che puoi eseguire sul tuo computer (per lo sviluppo) e sul cloud (per gestire il traffico reale). Puoi scrivere il codice puntando a una variabile d'ambiente chiamata `DATABASE_HOST`. Localmente, puoi settare quella variabile a `localhost`. Nel cloud, la puoi settare referenziando il [Service](https://kubernetes.io/it/docs/concepts/services-networking/service/ "A way to expose an application running on a set of Pods as a network service.")
di Kubernetes che espone la componente del database sul tuo cluster. Ciò ti permette di andare a recuperare l'immagine del container eseguita nel cloud e fare il debug dello stesso codice localmente se necessario.
La ConfigMap non è pensata per sostenere una gran mole di dati. I dati memorizzati su una ConfigMap non possono superare 1 MiB. Se hai bisogno di memorizzare delle configurazioni che superano questo limite, puoi considerare di montare un volume oppure usare un database o un file service separato.
Oggetto ConfigMap
-----------------
La ConfigMap è un [oggetto](https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/)
API che ti permette di salvare configurazioni per poi poter essere riutilizzate da altri oggetti. A differenza di molti oggetti di Kubernetes che hanno una `spec`, la ConfigMap ha i campi `data` e `binaryData`. Questi campi accettano le coppie chiave-valore come valori. Entrambi i campi `data` e `binaryData` sono opzionali. Il campo `data` è pensato per contenere le stringhe UTF-8 mentre il campo `binaryData` è pensato per contenere dati binari come le stringhe codificate in base64.
Il nome di una ConfigMap deve essere un nome valido per un sottodominio DNS.
Ogni chiave sotto il campo `data` o `binaryData` deve consistere di caratteri alfanumerici, `-`, `_` o `.`. Le chiavi salvate sotto `data` non devono coincidere con le chiavi nel campo `binaryData`.
Partendo dalla versione 1.19, puoi aggiungere il campo `immutable` alla definizione di ConfigMap per creare una [ConfigMap immutabile](https://kubernetes.io/it/docs/concepts/configuration/_print/#configmap-immutable)
.
ConfigMaps e Pods
-----------------
Puoi scrivere una `spec` del Pod che si riferisce a una ConfigMap e configurare il o i containers in quel Pod sulla base dei dati presenti nella ConfigMap. Il Pod e la ConfigMap devono essere nello stesso Namespace.
#### Nota:
La `spec` di un [Pod statico](https://kubernetes.io/it/docs/tasks/configure-pod-container/static-pod/ "A pod managed directly by the kubelet daemon on a specific node.")
non può riferirsi a una ConfigMap o ad altri oggetti API.
Questo è un esempio di una ConfigMap che ha alcune chiavi con valori semplici, e altre chiavi dove il valore ha il formato di un frammento di configurazione.
apiVersion: v1
kind: ConfigMap
metadata:
name: game-demo
data:
# chiavi simili a proprietà; ogni chiave mappa un valore semplice
player_initial_lives: "3"
ui_properties_file_name: "user-interface.properties"
# chiavi simili a files
game.properties: |
enemy.types=aliens,monsters
player.maximum-lives=5
user-interface.properties: |
color.good=purple
color.bad=yellow
allow.textmode=true
Ci sono quattro modi differenti con cui puoi usare una ConfigMap per configurare un container all'interno di un Pod:
1. Argomento da riga di comando come entrypoint di un container
2. Variabile d'ambiente di un container
3. Aggiungere un file in un volume di sola lettura, per fare in modo che l'applicazione lo legga
4. Scrivere il codice da eseguire all'interno del Pod che utilizza l'API di Kubernetes per leggere la ConfigMap
Questi metodologie differenti permettono di utilizzare diversi metodi per modellare i dati che saranno consumati. Per i primi tre metodi, il [kubelet](https://kubernetes.io/it/docs/reference/generated/kubelet "Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.")
utilizza i dati della ConfigMap quando lancia il container (o più) in un Pod.
Per il quarto metodo dovrai scrivere il codice per leggere la ConfigMap e i suoi dati. Comunque, poiché stai utilizzando l'API di Kubernetes direttamente, la tua applicazione può sottoscriversi per ottenere aggiornamenti ogniqualvolta la ConfigMap cambia, e reagire quando ciò accade. Accedendo direttamente all'API di Kubernetes, questa tecnica ti permette anche di accedere a una ConfigMap in namespace differenti.
Ecco un esempio di Pod che usa i valori da `game-demo` per configurare il container:
apiVersion: v1
kind: Pod
metadata:
name: configmap-demo-pod
spec:
containers:
- name: demo
image: alpine
command: ["sleep", "3600"]
env:
# Definire la variabile d'ambiente
- name: PLAYER_INITIAL_LIVES # Notare che il case qui è differente
# dal nome della key nella ConfigMap.
valueFrom:
configMapKeyRef:
name: game-demo # La ConfigMap da cui proviene il valore.
key: player_initial_lives # La chiave da recuperare.
- name: UI_PROPERTIES_FILE_NAME
valueFrom:
configMapKeyRef:
name: game-demo
key: ui_properties_file_name
volumeMounts:
- name: config
mountPath: "/config"
readOnly: true
volumes:
# Settare i volumi al livello del Pod, in seguito montarli nei containers all'interno del Pod
- name: config
configMap:
# Fornire il nome della ConfigMap che vuoi montare.
name: game-demo
# Una lista di chiavi dalla ConfigMap per essere creata come file
items:
- key: "game.properties"
path: "game.properties"
- key: "user-interface.properties"
path: "user-interface.properties"
Una ConfigMap non differenzia tra le proprietà di una singola linea e un file con più linee e valori. L'importante è il modo in cui i Pods e gli altri oggetti consumano questi valori.
Per questo esempio, definire un volume e montarlo all'interno del container `demo` come `/config` crea due files, `/config/game.properties` e `/config/user-interface.properties`, sebbene ci siano quattro chiavi nella ConfigMap. Ciò avviene perché la definizione del Pod specifica una lista di `items` nella sezione dei `volumes`. Se ometti del tutto la lista degli `items`, ogni chiave nella ConfigMap diventerà un file con lo stesso nome della chiave, e otterrai 4 files.
Usare le ConfigMaps
-------------------
Le ConfigMaps possono essere montate come volumi. Le ConfigMaps possono anche essere utilizzate da altre parti del sistema, senza essere direttamente esposte al Pod. Per esempio, le ConfigMaps possono contenere l'informazione che altre parti del sistema utilizzeranno per la loro configurazione.
La maniera più comune per usare le ConfigMaps è di configurare i containers che sono in esecuzione in un Pod nello stesso namespace. Puoi anche utilizzare una ConfigMap separatamente.
Per esempio, potresti incontrare [addons](https://kubernetes.io/it/docs/concepts/cluster-administration/addons/ "Resources that extend the functionality of Kubernetes.")
o [operators](https://kubernetes.io/it/docs/concepts/extend-kubernetes/operator/ "A specialized controller used to manage a custom resource")
che adattano il loro comportamento in base a una ConfigMap.
### Usare le ConfigMaps come files in un Pod
Per utilizzare una ConfigMap in un volume all'interno di un Pod:
1. Creare una ConfigMap o usarne una che già esiste. Più Pods possono utilizzare la stessa ConfigMap.
2. Modificare la definizione del Pod per aggiungere un volume sotto `.spec.volumes[]`. Nominare il volume in qualsiasi modo, e avere un campo `.spec.volumes[].configMap.name` configurato per referenziare il tuo oggetto ConfigMap.
3. Aggiungere un `.spec.containers[].volumeMounts[]` a ogni container che necessiti di una ConfigMap. Nello specifico `.spec.containers[].volumeMounts[].readOnly = true` e `.spec.containers[].volumeMounts[].mountPath` in una cartella inutilizzata dove vorresti che apparisse la ConfigMap.
4. Modificare l'immagine o il comando utilizzato così che il programma cerchi i files in quella cartella. Ogni chiave nella sezione `data` della ConfigMap si converte in un file sotto `mountPath`.
Questo è un esempio di un Pod che monta una ConfigMap in un volume:
apiVersion: v1
kind: Pod
metadata:
name: mypod
spec:
containers:
- name: mypod
image: redis
volumeMounts:
- name: foo
mountPath: "/etc/foo"
readOnly: true
volumes:
- name: foo
configMap:
name: myconfigmap
Ogni ConfigMap che desideri utilizzare deve essere referenziata in `.spec.volumes`.
Se c'è più di un container nel Pod, allora ogni container necessita del suo blocco `volumeMounts`, ma solamente un `.spec.volumes` è necessario ConfigMap.
#### Le ConfigMaps montate sono aggiornate automaticamente
Quando una ConfigMap è utilizzata in un volume ed è aggiornata, anche le chiavi vengono aggiornate. Il kubelet controlla se la ConfigMap montata è aggiornata ad ogni periodo di sincronizzazione. Ad ogni modo, il kubelet usa la sua cache locale per ottenere il valore attuale della ConfigMap. Il tipo di cache è configurabile usando il campo `ConfigMapAndSecretChangeDetectionStrategy` nel [KubeletConfiguration struct](https://kubernetes.io/docs/reference/config-api/kubelet-config.v1beta1/)
. Una ConfigMap può essere propagata per vista (default), ttl-based, o redirigendo tutte le richieste direttamente all'API server. Come risultato, il ritardo totale dal momento in cui la ConfigMap è aggiornata al momento in cui nuove chiavi sono propagate al Pod può essere tanto lungo quanto il periodo della sincronizzazione del kubelet + il ritardo della propagazione della cache, dove il ritardo della propagazione della cache dipende dal tipo di cache scelta (è uguale rispettivamente al ritardo della propagazione, ttl della cache, o zero).
Le ConfigMaps consumate come variabili d'ambiente non sono aggiornate automaticamente e necessitano di un riavvio del pod.
#### Nota:
Un container utilizzando una ConfigMap come un [subPath](https://kubernetes.io/docs/concepts/storage/volumes#using-subpath)
volume mount non riceverà gli aggiornamenti della ConfigMap.
ConfigMaps Immutabili
---------------------
FEATURE STATE: `Kubernetes v1.21 [stable]`
La funzionalità di Kubernetes _Immutable Secrets and ConfigMaps_ fornisce un'opzione per configurare Secrets individuali e ConfigMaps come immutabili. Per clusters che usano le ConfigMaps come estensione (almeno decine o centinaia di ConfigMap uniche montate nel Pod), prevenire i cambiamenti nei loro dati ha i seguenti vantaggi:
* protezione da aggiornamenti accidentali (o non voluti) che potrebbero causare l'interruzione di applicazioni
* miglioramento della performance del tuo cluster riducendo significativamente il carico sul kube-apiserver, chiudendo l'ascolto sulle ConfigMaps che sono segnate come immutabili.
Questa funzionalità è controllata dal `ImmutableEphemeralVolumes` [feature gate](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/)
. Puoi creare una ConfigMap immutabile settando il campo `immutable` a `true`. Per esempio:
apiVersion: v1
kind: ConfigMap
metadata:
...
data:
...
immutable: true
Una volta che una ConfigMap è segnata come immutabile, _non_ è possibile invertire questo cambiamento né cambiare il contenuto del campo `data` o `binaryData` field. Puoi solamente cancellare e ricreare la ConfigMap. Poiché i Pods hanno un puntamento verso la ConfigMap eliminata, è raccomandato di ricreare quei Pods.
Voci correlate
--------------
* Leggi in merito [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)
.
* Leggi [Configura un Pod per utilizzare una ConfigMap](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/)
.
* Leggi in merito [Modificare una ConfigMap (o qualsiasi altro oggetto di Kubernetes)](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/update-api-object-kubectl-patch/)
* Leggi [The Twelve-Factor App](https://12factor.net/)
per comprendere il motivo di separare il codice dalla configurazione.
---
# Instalando Complementos | Kubernetes
**Este documento pode estar desatualizado**
Este documento possui uma data de atualização mais antiga que o documento original. Portanto, este conteúdo pode estar desatualizado. Se você lê inglês, veja a versão em inglês para acessar a versão mais atualizada: [Installing Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
Instalando Complementos
=======================
**Nota:** Esta seção contém links para projetos de terceiros que fornecem a funcionalidade exigida pelo Kubernetes. Os autores do projeto Kubernetes não são responsáveis por esses projetos. Esta página obedece as [diretrizes de conteúdo do site CNCF](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
, listando os itens em ordem alfabética. Para adicionar um projeto a esta lista, leia o [guia de conteúdo](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
antes de enviar sua alteração.
Complementos estendem as funcionalidades do Kubernetes.
Esta página lista alguns dos complementos disponíveis e links com suas respectivas instruções de instalação.
Rede e Política de Rede
-----------------------
* [ACI](https://www.github.com/noironetworks/aci-containers)
fornece rede integrada de contêineres e segurança de rede com a Cisco ACI.
* [Antrea](https://antrea.io/)
opera nas camadas 3 e 4 do modelo de rede OSI para fornecer serviços de rede e de segurança para o Kubernetes, aproveitando o Open vSwitch como camada de dados de rede.
* [Calico](https://docs.projectcalico.org/latest/introduction/)
é um provedor de serviços de rede e de políticas de rede. Este complemento suporta um conjunto flexível de opções de rede, de modo a permitir a escolha da opção mais eficiente para um dado caso de uso, incluindo redes _overlay_ (sobrepostas) e não-_overlay_, com ou sem o uso do protocolo BGP. Calico usa o mesmo mecanismo para aplicar políticas de rede a hosts, pods, e aplicações na camada de _service mesh_ (quando Istio e Envoy estão instalados).
* [Canal](https://projectcalico.docs.tigera.io/getting-started/kubernetes/flannel/flannel)
une Flannel e Calico, fornecendo rede e política de rede.
* [Cilium](https://github.com/cilium/cilium)
é um plug-in de rede de camada 3 e de políticas de rede que pode aplicar políticas HTTP/API/camada 7 de forma transparente. Tanto o modo de roteamento quanto o de sobreposição/encapsulamento são suportados. Este plug-in também consegue operar no topo de outros plug-ins CNI.
* [CNI-Genie](https://github.com/cni-genie/CNI-Genie)
permite que o Kubernetes se conecte facilmente a uma variedade de plug-ins CNI, como Calico, Canal, Flannel, Romana ou Weave.
* [Contiv](https://contivpp.io/)
oferece serviços de rede configuráveis para diferentes casos de uso (camada 3 nativa usando BGP, _overlay_ (sobreposição) usando vxlan, camada 2 clássica e Cisco-SDN/ACI) e também um _framework_ rico de políticas de rede. O projeto Contiv é totalmente [open source](http://github.com/contiv)
. O [instalador](http://github.com/contiv/install)
fornece opções de instalação com ou sem kubeadm.
* [Contrail](http://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
é uma plataforma open source baseada no [Tungsten Fabric](https://tungsten.io/)
que oferece virtualização de rede multi-nuvem e gerenciamento de políticas de rede. O Contrail e o Tungsten Fabric são integrados a sistemas de orquestração de contêineres, como Kubernetes, OpenShift, OpenStack e Mesos, e fornecem modos de isolamento para cargas de trabalho executando em máquinas virtuais, contêineres/pods e servidores físicos.
* [Flannel](https://github.com/flannel-io/flannel#deploying-flannel-manually)
é um provedor de redes _overlay_ (sobrepostas) que pode ser usado com o Kubernetes.
* [Knitter](https://github.com/ZTE/Knitter/)
é um plug-in para suporte de múltiplas interfaces de rede em Pods do Kubernetes.
* [Multus](https://github.com/k8snetworkplumbingwg/multus-cni)
é um plugin para suporte a várias interfaces de rede em Pods no Kubernetes. Este plug-in pode agir como um "meta-plug-in", ou um plug-in CNI que se comunica com múltiplos outros plug-ins CNI (por exemplo, Calico, Cilium, Contiv, Flannel), além das cargas de trabalho baseadas em SRIOV, DPDK, OVS-DPDK e VPP no Kubernetes.
* [NSX-T](https://docs.vmware.com/en/VMware-NSX-T-Data-Center/index.html)
Container Plug-in (NCP) fornece integração entre o VMware NSX-T e sistemas de orquestração de contêineres como o Kubernetes. Além disso, oferece também integração entre o NSX-T e as plataformas CaaS/PaaS baseadas em contêiner, como o Pivotal Container Service (PKS) e o OpenShift.
* [Nuage](https://github.com/nuagenetworks/nuage-kubernetes/blob/v5.1.1-1/docs/kubernetes-1-installation.rst)
é uma plataforma de rede definida por software que fornece serviços de rede baseados em políticas entre os Pods do Kubernetes e os ambientes não-Kubernetes, com visibilidade e monitoramento de segurança.
* [OVN-Kubernetes](https://github.com/ovn-org/ovn-kubernetes/)
é um provedor de rede para o Kubernetes baseado no [OVN (Open Virtual Network)](https://github.com/ovn-org/ovn/)
, uma implementação de redes virtuais que surgiu através do projeto Open vSwitch (OVS). O OVN-Kubernetes fornece uma implementação de rede baseada em _overlay_ (sobreposição) para o Kubernetes, incluindo uma implementação baseada em OVS para serviços de balanceamento de carga e políticas de rede.
* [OVN4NFV-K8S-Plugin](https://github.com/opnfv/ovn4nfv-k8s-plugin)
é um plug-in controlador CNI baseado no OVN (Open Virtual Network) que fornece serviços de rede _cloud native_, como _Service Function Chaining_ (SFC), redes _overlay_ (sobrepostas) OVN múltiplas, criação dinâmica de subredes, criação dinâmica de redes virtuais, provedor de rede VLAN e provedor de rede direto, e é plugável a outros plug-ins multi-rede. Ideal para cargas de trabalho que utilizam computação de borda _cloud native_ em redes multi-cluster.
* [Romana](https://github.com/romana/romana)
é uma solução de rede de camada 3 para redes de pods que também suporta a [API NetworkPolicy](https://kubernetes.io/pt-br/docs/concepts/services-networking/network-policies/)
. Detalhes da instalação do complemento Kubeadm disponíveis [aqui](https://github.com/romana/romana/tree/master/containerize)
.
* [Weave Net](https://www.weave.works/docs/net/latest/kube-addon/)
fornece rede e política de rede, funciona em ambos os lados de uma partição de rede e não requer um banco de dados externo.
Descoberta de Serviço
---------------------
* [CoreDNS](https://coredns.io/)
é um servidor DNS flexível e extensível que pode ser [instalado](https://github.com/coredns/helm)
como o serviço de DNS dentro do cluster para ser utilizado por pods.
Visualização & Controle
-----------------------
* [Dashboard](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
é uma interface web para gestão do Kubernetes.
Infraestrutura
--------------
* [KubeVirt](https://kubevirt.io/user-guide/#/installation/installation)
é um complemento para executar máquinas virtuais no Kubernetes. É geralmente executado em clusters em máquina física.
Complementos Legados
--------------------
Existem vários outros complementos documentados no diretório [cluster/addons](https://git.k8s.io/kubernetes/cluster/addons)
que não são mais utilizados.
Projetos bem mantidos devem ser listados aqui. PRs são bem-vindos!
Comentários
-----------
Esta página foi útil?
Sim Não
Obrigado pelo feedback. Se você tiver uma pergunta específica sobre como utilizar o Kubernetes, faça em [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. Abra um bug no repositório do GitHub se você deseja [relatar um problema](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
ou [sugerir uma melhoria](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
Última modificação February 12, 2025 at 12:10 AM PST: [\[pt\] Fixed link for core dns helm charts (9bf945a4c6)](https://github.com/kubernetes/website/commit/9bf945a4c6fd8a07c12edc835e4b01112cc61fe3)
Itens nesta página referem-se a produtos ou projetos de terceiros que fornecem a funcionalidade requerida pelo Kubernetes. Os autores do projeto Kubernetes não são responsáveis por estes produtos ou projetos de terceiros. Veja as [diretrizes de conteúdo do site CNCF](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
para mais detalhes.
Você deve ler o [guia de conteúdo](https://kubernetes.io/pt-br/docs/contribute/style/content-guide/#third-party-content)
antes de propor alterações que incluam links extras de terceiros.
---
# Organizando o acesso ao cluster usando arquivos kubeconfig | Kubernetes
Organizando o acesso ao cluster usando arquivos kubeconfig
==========================================================
Utilize arquivos kubeconfig para organizar informações sobre clusters, usuários, namespaces e mecanismos de autenticação. A ferramenta de linha de comando `kubectl` faz uso dos arquivos kubeconfig para encontrar as informações necessárias para escolher e se comunicar com o serviço de API de um cluster.
#### Nota:
Um arquivo que é utilizado para configurar o acesso aos clusters é chamado de _kubeconfig_. Esta á uma forma genérica de referenciamento para um arquivo de configuração desta natureza. Isso não significa que existe um arquivo com o nome `kubeconfig`.
Por padrão, o `kubectl` procura por um arquivo de nome `config` no diretório `$HOME/.kube`
Você pode especificar outros arquivos kubeconfig através da variável de ambiente `KUBECONFIG` ou adicionando a opção [`--kubeconfig`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl/)
.
Para maiores detalhes na criação e especificação de um kubeconfig, veja o passo a passo em [Configurar Acesso para Múltiplos Clusters](https://kubernetes.io/pt-br/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
.
Suportando múltiplos clusters, usuários e mecanismos de autenticação
--------------------------------------------------------------------
Imagine que você possua inúmeros clusters, e seus usuários e componentes se autenticam de várias formas. Por exemplo:
* Um kubelet ativo pode se autenticar utilizando certificados
* Um usuário pode se autenticar através de tokens
* Administradores podem possuir conjuntos de certificados os quais provém acesso aos usuários de forma individual.
Através de arquivos kubeconfig, você pode organizar os seus clusters, usuários, e namespaces. Você também pode definir contextos para uma fácil troca entre clusters e namespaces.
Contexto
--------
Um elemento de _contexto_ em um kubeconfig é utilizado para agrupar parâmetros de acesso em um nome conveniente. Cada contexto possui três parâmetros: cluster, namespace, e usuário.
Por padrão, a ferramenta de linha de comando `kubectl` utiliza os parâmetros do _contexto atual_ para se comunicar com o cluster.
Para escolher o contexto atual:
kubectl config use-context
A variável de ambiente KUBECONFIG
---------------------------------
A variável de ambiente `KUBECONFIG` possui uma lista dos arquivos kubeconfig. Para Linux e Mac, esta lista é delimitada por vírgula. No Windows, a lista é delimitada por ponto e vírgula. A variável de ambiente `KUBECONFIG` não é um requisito obrigatório - caso ela não exista o `kubectl` utilizará o arquivo kubeconfig padrão localizado no caminho `$HOME/.kube/config`.
Se a variável de ambiente `KUBECONFIG` existir, o `kubectl` utilizará uma configuração que é o resultado da combinação dos arquivos listados na variável de ambiente `KUBECONFIG`.
Combinando arquivos kubeconfig
------------------------------
Para inspecionar a sua configuração atual, execute o seguinte comando:
kubectl config view
Como descrito anteriormente, a saída poderá ser resultado de um único arquivo kubeconfig, ou poderá ser o resultado da junção de vários arquivos kubeconfig.
Aqui estão as regras que o `kubectl` utiliza quando realiza a combinação de arquivos kubeconfig:
1. Se o argumento `--kubeconfig` está definido, apenas o arquivo especificado será utilizado. Apenas uma instância desta flag é permitida.
Caso contrário, se a variável de ambiente `KUBECONFIG` estiver definida, esta deverá ser utilizada como uma lista de arquivos a serem combinados, seguindo o fluxo a seguir:
* Ignorar arquivos vazios.
* Produzir erros para aquivos cujo conteúdo não for possível desserializar.
* O primeiro arquivo que definir um valor ou mapear uma chave determinada, será o escolhido.
* Nunca modificar um valor ou mapear uma chave. Exemplo: Preservar o contexto do primeiro arquivo que definir `current-context`. Exemplo: Se dois arquivos especificarem um `red-user`, use apenas os valores do primeiro `red-user`. Mesmo se um segundo arquivo possuir entradas não conflitantes sobre a mesma entrada `red-user`, estas deverão ser descartadas.
Para um exemplo de definição da variável de ambiente `KUBECONFIG` veja [Definido a variável de ambiente KUBECONFIG](https://kubernetes.io/pt-br/docs/tasks/access-application-cluster/configure-access-multiple-clusters/#set-the-kubeconfig-environment-variable)
.
Caso contrário, utilize o arquivo kubeconfig padrão encontrado no diretório `$HOME/.kube/config`, sem qualquer tipo de combinação.
2. Determine o contexto a ser utilizado baseado no primeiro padrão encontrado, nesta ordem:
1. Usar o conteúdo da flag `--context` caso ela existir.
2. Usar o `current-context` a partir da combinação dos arquivos kubeconfig.
Um contexto vazio é permitido neste momento.
3. Determinar o cluster e o usuário. Neste ponto, poderá ou não existir um contexto. Determinar o cluster e o usuário no primeiro padrão encontrado de acordo com a ordem à seguir. Este procedimento deverá executado duas vezes: uma para definir o usuário a outra para definir o cluster.
1. Utilizar a flag caso ela existir: `--user` ou `--cluster`.
2. Se o contexto não estiver vazio, utilizar o cluster ou usuário deste contexto.
O usuário e o cluster poderão estar vazios neste ponto.
4. Determinar as informações do cluster atual a serem utilizadas. Neste ponto, poderá ou não existir informações de um cluster.
Construir cada peça de informação do cluster baseado nas opções à seguir; a primeira ocorrência encontrada será a opção vencedora:
1. Usar as flags de linha de comando caso existirem: `--server`, `--certificate-authority`, `--insecure-skip-tls-verify`.
2. Se algum atributo do cluster existir a partir da combinação de kubeconfigs, estes deverão ser utilizados.
3. Se não existir informação de localização do servidor falhar.
5. Determinar a informação atual de usuário a ser utilizada. Construir a informação de usuário utilizando as mesmas regras utilizadas para o caso de informações de cluster, exceto para a regra de técnica de autenticação que deverá ser única por usuário:
1. Usar as flags, caso existirem: `--client-certificate`, `--client-key`, `--username`, `--password`, `--token`.
2. Usar os campos `user` resultado da combinação de arquivos kubeconfig.
3. Se existirem duas técnicas conflitantes, falhar.
6. Para qualquer informação que ainda estiver ausente, utilizar os valores padrão e potencialmente solicitar informações de autenticação a partir do prompt de comando.
Referências de arquivos
-----------------------
Arquivos e caminhos referenciados em um arquivo kubeconfig são relativos à localização do arquivo kubeconfig.
Referências de arquivos na linha de comando são relativas ao diretório de trabalho vigente.
No arquivo `$HOME/.kube/config`, caminhos relativos são armazenados de forma relativa, e caminhos absolutos são armazenados de forma absoluta.
Próximos passos
---------------
* [Configurar Acesso para Multiplos Clusters](https://kubernetes.io/pt-br/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
* [`kubectl config`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#config)
Comentários
-----------
Esta página foi útil?
Sim Não
Obrigado pelo feedback. Se você tiver uma pergunta específica sobre como utilizar o Kubernetes, faça em [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
. Abra um bug no repositório do GitHub se você deseja [relatar um problema](https://github.com/kubernetes/website/issues/new?title=Issue%20with%20k8s.io)
ou [sugerir uma melhoria](https://github.com/kubernetes/website/issues/new?title=Improvement%20for%20k8s.io)
.
Última modificação November 24, 2025 at 9:32 AM PST: [Fixed wording accesso. (ab2a84e909)](https://github.com/kubernetes/website/commit/ab2a84e909332edf982e7c2488c3ba1f9fdc956b)
---
# Architettura di Kubernetes | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/concepts/architecture/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/concepts/architecture/)
.
Architettura di Kubernetes
==========================
* 1: [Comunicazione Control Plane - Nodo](https://kubernetes.io/it/docs/concepts/architecture/_print/#pg-c0251def6da29b30afebfb04549f1703)
* 2: [Concetti alla base del Cloud Controller Manager](https://kubernetes.io/it/docs/concepts/architecture/_print/#pg-bc804b02614d67025b4c788f1ca87fbc)
* 3: [Controller](https://kubernetes.io/it/docs/concepts/architecture/_print/#pg-ca8819042a505291540e831283da66df)
1 - Comunicazione Control Plane - Nodo
======================================
Questo documento cataloga le connessioni tra il piano di controllo (_control-plane_), in realtà l'apiserver, e il cluster Kubernetes. L'intento è di consentire agli utenti di personalizzare la loro installazione per rafforzare la configurazione di rete affinché il cluster possa essere eseguito su una rete pubblica (o su IP completamente pubblici resi disponibili da un fornitore di servizi cloud).
Dal Nodo al control-plane
-------------------------
Kubernetes adotta un pattern per le API di tipo _"hub-and-spoke"_. Tutte le chiamate delle API eseguite sui vari nodi sono effettuate verso l'apiserver (nessuno degli altri componenti principali è progettato per esporre servizi remoti). L'apiserver è configurato per l'ascolto di connessioni remote su una porta HTTPS protetta (443) con una o più forme di [autenticazioni client](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)
abilitate. Si dovrebbero abilitare una o più forme di [autorizzazioni](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)
, in particolare nel caso in cui siano ammesse [richieste anonime](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#anonymous-requests)
o [_token_ legati ad un account di servizio (_service account_)](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#service-account-tokens)
.
Il certificato pubblico (_public root certificate_) relativo al cluster corrente deve essere fornito ai vari nodi di modo che questi possano connettersi in modo sicuro all'apiserver insieme alle credenziali valide per uno specifico _client_. Ad esempio, nella configurazione predefinita di un cluster [GKE](https://cloud.google.com/kubernetes-engine?hl=it)
, le credenziali del client fornite al kubelet hanno la forma di un certificato client. Si veda [inizializzazione TLS del kubelet TLS](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet-tls-bootstrapping/)
per la fornitura automatica dei certificati client al _kubelet_.
I Pod che desiderano connettersi all'apiserver possono farlo in modo sicuro sfruttando un account di servizio in modo che Kubernetes inserisca automaticamente il certificato pubblico di radice e un token valido al portatore (_bearer token_) all'interno Pod quando questo viene istanziato. In tutti i namespace è configurato un _Service_ con nome `kubernetes` con un indirizzo IP virtuale che viene reindirizzato (tramite _kube-proxy_) all'endpoint HTTPS dell'apiserver.
Anche i componenti del piano d controllo comunicano con l'apiserver del cluster su di una porta sicura esposta da quest'ultimo.
Di conseguenza, la modalità operativa predefinita per le connessioni dai nodi e dai Pod in esecuzione sui nodi verso il _control-plane_ è protetta da un'impostazione predefinita e può essere eseguita su reti non sicure e/o pubbliche.
Dal control-plane al nodo
-------------------------
Esistono due percorsi di comunicazione principali dal _control-plane_ (apiserver) verso i nodi. Il primo è dall'apiserver verso il processo _kubelet_ in esecuzione su ogni nodo nel cluster. Il secondo è dall'apiserver a ciascun nodo, Pod, o servizio attraverso la funzionalità proxy dell'apiserver.
### Dall'apiserver al _kubelet_
Le connessioni dall'apiserver al _kubelet_ vengono utilizzate per:
* Prendere i log relativi ai vari Pod.
* Collegarsi (attraverso kubectl) ai Pod in esecuzione.
* Fornire la funzionalità di _port-forwarding_ per i _kubelet_.
Queste connessioni terminano all'endpoint HTTPS del _kubelet_. Di default, l'apiserver non verifica il certificato servito dal _kubelet_, il che rende la connessione soggetta ad attacchi _man-in-the-middle_, e tale da essere considerato **non sicuro (unsafe)** se eseguito su reti non protette e/o pubbliche.
Per verificare questa connessione, si utilizzi il parametro `--kubelet-certificate-authority` al fine di fornire all'apiserver un insieme di certificati radice da utilizzare per verificare il il certificato servito dal _kubelet_.
Se questo non è possibile, si usi un [tunnel SSH](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/)
tra l'apiserver e il _kubelet_, se richiesto, per evitare il collegamento su una rete non protetta o pubblica.
In fine, l'[autenticazione e/o l'autorizzazione del kubelet](https://kubernetes.io/docs/admin/kubelet-authentication-authorization/)
dovrebbe essere abilitate per proteggere le API esposte dal _kubelet_.
### Dall'apiserver ai nodi, Pod, e servizi
Le connessioni dall'apiserver verso un nodo, Pod o servizio avvengono in modalità predefinita su semplice connessione HTTP e quindi non sono né autenticate né criptata. Queste connessioni possono essere eseguite su una connessione HTTPS sicura mediante il prefisso `https:` al nodo, Pod o nome del servizio nell'URL dell'API, ma non valideranno il certificato fornito dall'endpoint HTTPS né forniranno le credenziali del client così anche se la connessione verrà criptata, non fornirà alcuna garanzia di integrità. **Non è attualmente sicuro** eseguire queste connessioni su reti non protette e/o pubbliche.
### I tunnel SSH
Kubernetes supporta i _tunnel_ SSH per proteggere la comunicazione tra il _control-plane_ e i nodi. In questa configurazione, l'apiserver inizializza un tunnel SSH con ciascun nodo del cluster (collegandosi al server SSH in ascolto sulla porta 22) e fa passare tutto il traffico verso il _kubelet_, il nodo, il Pod, o il servizio attraverso questo tunnel. Questo tunnel assicura che il traffico non sia esposto al di fuori della rete su cui sono in esecuzioni i vari nodi.
I tunnel SSH sono al momento deprecati ovvero non dovrebbero essere utilizzati a meno che ci siano delle esigenze particolari. Il servizio `Konnectivity` è pensato per rimpiazzare questo canale di comunicazione.
### Il servizio _Konnectivity_
FEATURE STATE: `Kubernetes v1.18 [beta]`
Come rimpiazzo dei tunnel SSH, il servizio _Konnectivity_ fornisce un proxy a livello TCP per la comunicazione tra il _control-plane_ e il cluster. Il servizio _Konnectivity_ consiste in due parti: il _Konnectivity_ server e gli agenti _Konnectivity_, in esecuzione rispettivamente sul _control-plane_ e sui vari nodi. Gli agenti _Konnectivity_ inizializzano le connessioni verso il server _Konnectivity_ e mantengono le connessioni di rete. Una volta abilitato il servizio _Konnectivity_, tutto il traffico tra il _control-plane_ e i nodi passa attraverso queste connessioni.
Si può fare riferimento al [tutorial per il servizio _Konnectivity_](https://kubernetes.io/docs/tasks/extend-kubernetes/setup-konnectivity/)
per configurare il servizio _Konnectivity_ all'interno del cluster
2 - Concetti alla base del Cloud Controller Manager
===================================================
Il concetto di CCM (cloud controller manager), da non confondere con il binario, è stato originariamente creato per consentire di sviluppare Kubernetes indipendentemente dall'implementazione dello specifico cloud provider. Il cloud controller manager viene eseguito insieme ad altri componenti principali come il Kubernetes controller manager, il server API e lo scheduler. Può anche essere avviato come addon di Kubernetes, nel qual caso viene eseguito su Kubernetes.
Il design del cloud controller manager è basato su un meccanismo di plug-in che consente ai nuovi provider cloud di integrarsi facilmente con Kubernetes creando un plug-in. Sono in atto programmi per l'aggiunta di nuovi provider di cloud su Kubernetes e per la migrazione dei provider che usano il vecchio metodo a questo nuovo metodo.
Questo documento discute i concetti alla base del cloud controller manager e fornisce dettagli sulle funzioni associate.
Ecco l'architettura di un cluster Kubernetes senza il gestore del controller cloud:

Architettura
------------
Nel diagramma precedente, Kubernetes e il provider cloud sono integrati attraverso diversi componenti:
* Kubelet
* Kubernetes controller manager
* Kubernetes API server
Il CCM consolida tutta la logica dipendente dal cloud presente nei tre componenti precedenti, per creare un singolo punto di integrazione con il cloud. La nuova architettura con il CCM si presenta così:

Componenti del CCM
------------------
Il CCM divide alcune funzionalità del Kubernetes controller manager (KCM) e le esegue in un differente processo. In particolare, toglie dal KCM le integrazioni con il cloud specifico. Il KCM ha i seguenti controller che dipendono dal cloud specifico:
* Node controller
* Volume controller
* Route controller
* Service controller
Nella versione 1.9, il CCM esegue i seguenti controller dall'elenco precedente:
* Node controller
* Route controller
* Service controller
#### Nota:
È stato deliberatamente deciso di non spostare il Volume controller nel CCM. Data la complessità del Volume controller e gli sforzi già fatti per astrarre le logiche specifiche dei singoli fornitori, è stato deciso che il Volume controller non verrà spostato nel CCM.
Il piano originale per supportare i volumi utilizzando il CCM era di utilizzare [Flex](https://kubernetes.io/docs/concepts/storage/volumes/#flexVolume)
per supportare volumi collegabili. Tuttavia, una implementazione parallela, nota come [CSI](https://kubernetes.io/docs/concepts/storage/volumes/#csi)
è stata designata per sostituire Flex.
Considerando queste evoluzioni, abbiamo deciso di adottare un approccio intermedio finché il CSI non è pronto.
Funzioni del CCM
----------------
Il CCM eredita le sue funzioni da componenti di Kubernetes che dipendono da uno specifico provider di cloud. Questa sezione è strutturata sulla base di tali componenti.
### 1\. Kubernetes controller manager
La maggior parte delle funzioni del CCM deriva dal KCM. Come menzionato nella sezione precedente, CCM esegue i seguenti cicli di controllo:
* Node controller
* Route controller
* Service controller
#### Node controller
Il Node controller è responsabile per l'inizializzazione di un nodo ottenendo informazioni sui nodi in esecuzione nel cluster dal provider cloud. Il controller del nodo esegue le seguenti funzioni:
1. Inizializzare un nodo con le label zone/region specifiche per il cloud in uso.
2. Inizializzare un nodo con le specifiche, ad esempio, tipo e dimensione specifiche del cloud in uso.
3. Ottenere gli indirizzi di rete del nodo e l'hostname.
4. Nel caso in cui un nodo non risponda, controlla il cloud per vedere se il nodo è stato cancellato dal cloud. Se il nodo è stato eliminato dal cloud, elimina l'oggetto Nodo di Kubernetes.
#### Route controller
Il Route controller è responsabile della configurazione delle route nel cloud in modo che i container su nodi differenti del cluster Kubernetes possano comunicare tra loro. Il Route controller è utilizzabile solo dai cluster su Google Compute Engine.
#### Service Controller
Il Service Controller rimane in ascolto per eventi di creazione, aggiornamento ed eliminazione di servizi. In base allo stato attuale dei servizi in Kubernetes, configura i bilanciatori di carico forniti dal cloud (come gli ELB, i Google LB, o gli Oracle Cloud Infrastructure LB) per riflettere lo stato dei servizi in Kubernetes. Inoltre, assicura che i back-end dei bilanciatori di carico forniti dal cloud siano aggiornati.
### 2\. Kubelet
Il Node Controller contiene l'implementazione dipendente dal cloud della kubelet. Prima dell'introduzione del CCM, la kubelet era responsabile dell'inizializzazione di un nodo con dettagli dipendenti dallo specifico cloud come gli indirizzi IP, le label region/zone e le informazioni sul tipo di istanza. L'introduzione del CCM ha spostato questa operazione di inizializzazione dalla kubelet al CCM.
In questo nuovo modello, la kubelet inizializza un nodo senza informazioni specifiche del cloud. Tuttavia, aggiunge un blocco al nodo appena creato che rende il nodo non selezionabile per eseguire container finché il CCM non inizializza il nodo con le informazioni specifiche del cloud. Il CCM rimuove quindi questo blocco.
Sistema a plug-in
-----------------
Il cloud controller manager utilizza le interfacce di Go per consentire l'implementazione di implementazioni di qualsiasi cloud. In particolare, utilizza l'interfaccia CloudProvider definita [qui](https://github.com/kubernetes/cloud-provider/blob/9b77dc1c384685cb732b3025ed5689dd597a5971/cloud.go#L42-L62)
.
L'implementazione dei quattro controller generici evidenziati sopra, alcune strutture, l'interfaccia cloudprovider condivisa rimarranno nel core di Kubernetes. Le implementazioni specifiche per i vari cloud saranno costruite al di fuori del core e implementeranno le interfacce definite nel core.
Per ulteriori informazioni sullo sviluppo di plug-in, consultare [Developing Cloud Controller Manager](https://kubernetes.io/docs/tasks/administer-cluster/developing-cloud-controller-manager/)
.
Autorizzazione
--------------
Questa sezione dettaglia l'accesso richiesto dal CCM sui vari API objects per eseguire le sue operazioni.
### Node controller
Il Node controller funziona solo con oggetti di tipo Node. Richiede l'accesso completo per ottenere, elencare, creare, aggiornare, applicare patch, guardare ed eliminare oggetti di tipo Node.
v1/Node:
* Get
* List
* Create
* Update
* Patch
* Watch
* Delete
### Route controller
Il Route controller ascolta la creazione dell'oggetto Node e configura le rotte in modo appropriato. Richiede l'accesso in lettura agli oggetti di tipo Node.
v1/Node:
* Get
### Service controller
Il Service controller resta in ascolto per eventi di creazione, aggiornamento ed eliminazione di oggetti di tipo Servizi, e configura gli endpoint per tali Servizi in modo appropriato.
Per accedere ai Servizi, è necessario il permesso per list e watch. Per aggiornare i Servizi, sono necessari i permessi patch e update.
Per impostare gli endpoint per i Servizi, richiede i permessi create, list, get, watch, e update.
v1/Service:
* List
* Get
* Watch
* Patch
* Update
### Others
L'implementazione del core di CCM richiede l'accesso per creare eventi e, per garantire operazioni sicure, richiede l'accesso per creare ServiceAccounts.
v1/Event:
* Create
* Patch
* Update
v1/ServiceAccount:
* Create
L'RBAC ClusterRole per il CCM ha il seguente aspetto:
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: cloud-controller-manager
rules:
- apiGroups:
- ""
resources:
- events
verbs:
- create
- patch
- update
- apiGroups:
- ""
resources:
- nodes
verbs:
- '*'
- apiGroups:
- ""
resources:
- nodes/status
verbs:
- patch
- apiGroups:
- ""
resources:
- services
verbs:
- list
- patch
- update
- watch
- apiGroups:
- ""
resources:
- serviceaccounts
verbs:
- create
- apiGroups:
- ""
resources:
- persistentvolumes
verbs:
- get
- list
- update
- watch
- apiGroups:
- ""
resources:
- endpoints
verbs:
- create
- get
- list
- watch
- update
Vendor Implementations
----------------------
I seguenti fornitori di cloud hanno una implementazione di CCM:
* [Alibaba Cloud](https://github.com/kubernetes/cloud-provider-alibaba-cloud)
* [AWS](https://github.com/kubernetes/cloud-provider-aws)
* [Azure](https://github.com/kubernetes/cloud-provider-azure)
* [BaiduCloud](https://github.com/baidu/cloud-provider-baiducloud)
* [DigitalOcean](https://github.com/digitalocean/digitalocean-cloud-controller-manager)
* [GCP](https://github.com/kubernetes/cloud-provider-gcp)
* [Hetzner](https://github.com/hetznercloud/hcloud-cloud-controller-manager)
* [Linode](https://github.com/linode/linode-cloud-controller-manager)
* [OpenStack](https://github.com/kubernetes/cloud-provider-openstack)
* [Oracle](https://github.com/oracle/oci-cloud-controller-manager)
* [TencentCloud](https://github.com/TencentCloud/tencentcloud-cloud-controller-manager)
Cluster Administration
----------------------
Le istruzioni complete per la configurazione e l'esecuzione del CCM sono fornite [qui](https://kubernetes.io/docs/tasks/administer-cluster/running-cloud-controller/#cloud-controller-manager)
.
3 - Controller
==============
Nella robotica e nell'automazione, un _circuito di controllo_ (_control loop_) è un un'iterazione senza soluzione di continuità che regola lo stato di un sistema.
Ecco un esempio di un circuito di controllo: il termostato di una stanza.
Quando viene impostata la temperatura, si definisce attraverso il termostato lo _stato desiderato_. L'attuale temperatura nella stanza è invece lo _stato corrente_. Il termostato agisce per portare lo stato corrente il più vicino possibile allo stato desiderato accendendo e spegnendo le apparecchiature.
In Kubernetes, i _controller_ sono circuiti di controllo che osservano lo stato del [cluster](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-cluster "Un'insieme di macchine, chiamate nodi, che eseguono container gestiti da Kubernetes. Un cluster ha almeno un Worker Node.")
, e apportano o richiedono modifiche quando necessario. Ogni _controller_ prova a portare lo stato corrente del cluster verso lo stato desiderato.
Il modello del controller
-------------------------
Un _controller_ monitora almeno una tipo di risorsa registrata in Kubernetes. Questi [oggetti](https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/#kubernetes-objects)
hanno una proprietà chiamata _spec_ (specifica) che rappresenta lo stato desiderato. Il o i _controller_ per quella risorsa sono responsabili di mantenere lo stato corrente il più simile possibile rispetto allo stato desiderato.
Il _controller_ potrebbe eseguire l'azione relativa alla risorsa in questione da sé; più comunemente, in Kubernetes, un _controller_ invia messaggi all'[API server](https://kubernetes.io/it/docs/concepts/architecture/#kube-apiserver "Componente della Control plane che serve le Kubernetes API.")
che a sua volta li rende disponibili ad altri componenti nel cluster. Di seguito troverete esempi per questo scenario.
### Controllo attraverso l'API server
Il [Job](https://kubernetes.io/it/docs/concepts/workloads/controllers/jobs-run-to-completion "Uno o più lavori (task) che vengono eseguiti fino al loro completamento.")
_controller_ è un esempio di un _controller_ nativo in Kubernetes. I _controller_ nativi gestiscono lo stato interagendo con l'API server presente nel cluster.
Il Job è una risorsa di Kubernetes che lancia uno o più [Pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
per eseguire un lavoro (task) e poi fermarsi.
(Una volta che è stato [schedulato](https://kubernetes.io/docs/concepts/scheduling-eviction/)
, un oggetto _Pod_ diventa parte dello stato desisderato di un dato _kubelet_).
Quando il Job _controller_ vede un nuovo lavoro da svolgere si assicura che, da qualche parte nel cluster, i _kubelet_ anche sparsi su più nodi eseguano il numero corretto di _Pod_ necessari per eseguire il lavoro richiesto. Il Job _controller_ non esegue direttamente alcun _Pod_ o _container_ bensì chiede all'API server di creare o rimuovere i _Pod_. Altri componenti appartenenti al [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
reagiscono in base alle nuove informazioni (ci sono nuovi _Pod_ da creare e gestire) e cooperano al completamento del job.
Dopo che un nuovo Job è stato creato, lo stato desiderato per quel Job è il suo completamento. Il Job _controller_ fa sì che lo stato corrente per quel Job sia il più vicino possibile allo stato desiderato: creare _Pod_ che eseguano il lavoro che deve essere effettuato attraverso il Job, così che il Job sia prossimo al completamento.
I _controller_ aggiornano anche gli oggetti che hanno configurato. Ad esempio: una volta che il lavoro relativo ad un dato Job è stato completato, il Job _controller_ aggiorna l'oggetto Job segnandolo come `Finished`.
(Questo è simile allo scenario del termostato che spegne un certo led per indicare che ora la stanza ha raggiungo la temperatura impostata)
### Controllo diretto
A differenza del Job, alcuni _controller_ devono eseguire delle modifiche a parti esterne al cluster.
Per esempio, se viene usato un circuito di controllo per assicurare che ci sia un numero sufficiente di [Nodi](https://kubernetes.io/it/docs/concepts/architecture/nodes/ "Un node è una macchina worker in Kubernetes.")
nel cluster, allora il _controller_ ha bisogno che qualcosa al di fuori del cluster configuri i nuovi _Nodi_ quando sarà necessario.
I _controller_ che interagiscono con un sistema esterno trovano il loro stato desiderato attraverso l'API server, quindi comunicano direttamente con un sistema esterno per portare il loro stato corrente più in linea possibile con lo stato desiderato
(In realtà c'è un _controller_ che scala orizzontalmente i nodi nel cluster. Vedi [Cluster autoscaling](https://kubernetes.io/docs/tasks/administer-cluster/cluster-management/#cluster-autoscaling)
).
Stato desiderato versus corrente
--------------------------------
Kubernetes ha una visione _cloud-native_ dei sistemi, ed è in grado di gestire continue modifiche.
Il cluster viene modificato continuamente durante la sua attività ed il _circuito di controllo_ è in grado di risolvere automaticamente i possibili guasti.
Fino a che i _controller_ del cluster sono in funzione ed in grado di apportare le dovute modifiche, non è rilevante che lo stato complessivo del cluster sia o meno stabile.
Progettazione
-------------
Come cardine della sua progettazione, Kubernetes usa vari _controller_ ognuno dei quali è responsabile per un particolare aspetto dello stato del cluster. Più comunemente, un dato _circuito di controllo_ (_controller_) usa un tipo di risorsa per il suo stato desiderato, ed utilizza anche risorse di altro tipo per raggiungere questo stato desiderato. Per esempio il Job _controller_ tiene traccia degli oggetti di tipo _Job_ (per scoprire nuove attività da eseguire) e degli oggetti di tipo _Pod_ (questi ultimi usati per eseguire i _Job_, e quindi per controllare quando il loro lavoro è terminato). In questo caso, qualcos'altro crea i _Job_, mentre il _Job_ _controller_ crea i _Pod_.
È utile avere semplici _controller_ piuttosto che un unico, monolitico, _circuito di controllo_. I _controller_ possono guastarsi, quindi Kubernetes è stato disegnato per gestire questa eventualità.
#### Nota:
Ci possono essere diversi _controller_ che creato o aggiornano lo stesso tipo di oggetti. Dietro le quinte, i _controller_ di Kubernetes si preoccupano esclusivamente delle risorse (di altro tipo) collegate alla risorsa primaria da essi controllata.
Per esempio, si possono avere _Deployment_ e _Job_; entrambe creano _Pod_. Il Job _controller_ non distrugge i _Pod_ creati da un _Deployment_, perché ci sono informazioni (_[labels](https://kubernetes.io/it/docs/concepts/overview/working-with-objects/labels "Tags di oggetti con attributi identificativi che sono significativi e pertinenti per gli utenti.")
_) che vengono usate dal _controller_ per distinguere i _Pod_.
I modi per eseguire i _controller_
----------------------------------
Kubernetes annovera un insieme di _controller_ nativi che sono in esecuzione all'interno del [kube-controller-manager](https://kubernetes.io/it/docs/reference/command-line-tools-reference/kube-controller-manager/ "Componente della Control Plane che gestisce i controller.")
. Questi _controller_ nativi forniscono importanti funzionalità di base.
Il Deployment _controller_ ed il Job _controller_ sono esempi di _controller_ che vengono forniti direttamente da Kubernetes stesso (ovvero _controller_ "nativi"). Kubernetes consente di eseguire un _piano di controllo_(_control plane_) resiliente, di modo che se un dei _controller_ nativi dovesse fallire, un'altra parte del piano di controllo si occuperà di eseguire quel lavoro.
Al fine di estendere Kubernetes, si possono avere _controller_ in esecuzione al di fuori del piano di controllo. Oppure, se si desidera, è possibile scriversi un nuovo _controller_. È possibile eseguire il proprio controller come una serie di _Pod_, oppure esternamente rispetto a Kubernetes. Quale sia la soluzione migliore, dipende dalla responsabilità di un dato controller.
Voci correlate
--------------
* Leggi in merito [Kubernetes control plane](https://kubernetes.io/it/docs/concepts/#kubernetes-control-plane)
* Scopri alcune delle basi degli [oggetti di Kubernetes](https://kubernetes.io/it/docs/concepts/#kubernetes-objects)
* Per saperne di più riguardo alle [API di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/kubernetes-api/)
* Se vuoi creare un tuo _controller_, guarda [i modelli per l'estensibilità](https://kubernetes.io/docs/concepts/extend-kubernetes/extend-cluster/#extension-patterns)
in Estendere Kubernetes.
---
# Containers | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/concepts/containers/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/concepts/containers/)
.
Containers
==========
La tecnologia per distribuire un'applicazione insieme con le dipendenze necessarie per la sua esecuzione.
* 1: [Immagini](https://kubernetes.io/it/docs/concepts/containers/_print/#pg-16042b4652ad19e565c7263824029a43)
* 2: [Container Environment](https://kubernetes.io/it/docs/concepts/containers/_print/#pg-643212488f778acf04bebed65ba34441)
* 3: [Container Lifecycle Hooks](https://kubernetes.io/it/docs/concepts/containers/_print/#pg-e6941d969d81540208a3e78bc56f43bc)
Ogni _container_ che viene eseguito è riproducibile; la pratica di includere le dipendenze all'interno di ciascuno _container_ permette di ottenere sempre lo stesso risultato ad ogni esecuzione del medesimo _container_.
I _Container_ permettono di disaccoppiare le applicazioni dall'infrastruttura del host su cui vengono eseguite. Questo approccio rende più facile il _deployment_ su cloud o sitemi operativi differenti tra loro.
Immagine di container
---------------------
L'[immagine di un container](https://kubernetes.io/it/docs/concepts/containers/images/)
e' un pacchetto software che contiene tutto ciò che serve per eseguire un'applicazione: il codice sorgente e ciascun _runtime_ necessario, librerie applicative e di sistema, e le impostazioni predefinite per ogni configurazione necessaria.
Un _container_ è immutabile per definizione: non è possibile modificare il codice di un _container_ in esecuzione. Se si ha un'applicazione containerizzata e la si vuole modificare, si deve costruire un nuovo _container_ che includa il cambiamento desiderato, e quindi ricreare il _container_ partendo dalla nuova immagine aggiornata.
Container runtimes
------------------
Il container runtime è il software che è responsabile per l'esecuzione dei container.
Kubernetes supporta diversi container runtimes: [Docker](http://www.docker.com/)
, [containerd](https://containerd.io/)
, [cri-o](https://cri-o.io/)
, [rktlet](https://github.com/kubernetes-incubator/rktlet)
e tutte le implementazioni di [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Voci correlate
--------------
* Leggi in merito [immagine di container](https://kubernetes.io/it/docs/concepts/containers/images/)
* Leggi in merito [Pods](https://kubernetes.io/docs/concepts/workloads/pods/)
1 - Immagini
============
L'immagine di un container rappresenta dati binari che incapsulano un'applicazione e tutte le sue dipendenze software. Le immagini sono costituite da pacchetti software eseguibili che possono essere avviati in modalità standalone e su cui si possono fare ipotesi ben precise circa l'ambiente in cui vengono eseguiti.
Tipicamente viene creata un'immagine di un'applicazione ed effettuato il _push_ su un registry (un repository pubblico di immagini) prima di poterne fare riferimento esplicito in un [Pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
Questa pagina va a delineare nello specifico il concetto di immagine di un container.
I nomi delle immagini
---------------------
Alle immagini dei container vengono normalmente attribuiti nomi come `pause`, `example/mycontainer`, o `kube-apiserver`. Le immagini possono anche contenere l'hostname del registry in cui le immagini sono pubblicate; ad esempio: `registro.fittizio.esempio/nomeimmagine`, ed è possibile che sia incluso nel nome anche il numero della porta; ad esempio: `registro.fittizio.esempio:10443/nomeimmagine`.
Se non si specifica l'hostname di un registry, Kubernetes assume che ci si riferisca al registry pubblico di Docker.
Dopo la parte relativa al nome dell'immagine si può aggiungere un _tag_ (come comunemente avviene per comandi come `docker` e `podman`). I tag permettono l'identificazione di differenti versioni della stessa serie di immagini.
I tag delle immagini sono composti da lettere minuscole e maiuscole, numeri, underscore (`_`), punti (`.`), e trattini (`-`).
Esistono regole aggiuntive relative a dove i caratteri separatori (`_`, `-`, and `.`) possano essere inseriti nel tag di un'immagine. Se non si specifica un tag, Kubernetes assume il tag `latest` che va a definire l'immagine disponibile più recente.
#### Attenzione:
Evitate di utilizzare il tag `latest` quando si rilasciano dei container in produzione, in quanto risulta difficile tracciare quale versione dell'immagine sia stata avviata e persino più difficile effettuare un rollback ad una versione precente.
Invece, meglio specificare un tag specifico come ad esempio `v1.42.0`.
Aggiornamento delle immagini
----------------------------
Quando un [Deployment](https://kubernetes.io/it/docs/concepts/workloads/controllers/deployment/ "Gestisce una applicazione replicata nel tuo cluster.")
, [StatefulSet](https://kubernetes.io/it/docs/concepts/workloads/controllers/statefulset/ "Gestisce deployment e la scalabilità di un gruppo di Pod, con storage e identificativi persistenti per ogni Pod.")
, Pod, o qualsiasi altro oggetto che includa un Pod template viene creato per la prima volta, la policy di default per il pull di tutti i container nel Pod è impostata su `IfNotPresent` (se non presente) se non specificato diversamente. Questa policy permette al [kubelet](https://kubernetes.io/it/docs/reference/generated/kubelet "Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.")
di evitare di fare il pull di un'immagine se questa è già presente.
Se necessario, si può forzare il pull in ogni occasione in uno dei seguenti modi:
* impostando `imagePullPolicy` (specifica per il pull delle immagini) del container su `Always` (sempre).
* omettendo `imagePullPolicy` ed usando il tag `:latest` (più recente) per l'immagine da utilizzare; Kubernetes imposterà la policy su `Always` (sempre).
* omettendo `imagePullPolicy` ed il tag per l'immagine da utilizzare.
* abilitando l'admission controller [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
.
#### Nota:
Il valore dell'impostazione `imagePullPolicy` del container è sempre presente quando l'oggetto viene creato per la prima volta e non viene aggiornato se il tag dell'immagine dovesse cambiare successivamente.
Ad esempio, creando un Deployment con un'immagine il cui tag _non_ è `:latest`, e successivamente aggiornando il tag di quell'immagine a `:latest`, il campo `imagePullPolicy` _non_ cambierà su `Always`. È necessario modificare manualmente la policy di pull di ogni oggetto dopo la sua creazione.
Quando `imagePullPolicy` è definito senza un valore specifico, esso è impostato su `Always`.
Multi-architecture support nelle immagini
-----------------------------------------
Oltre a fornire immagini binarie, un _container registry_ può fornire un [indice delle immagini disponibili per un container](https://github.com/opencontainers/image-spec/blob/master/image-index.md)
. L'indice di un'immagine può puntare a più [file manifest](https://github.com/opencontainers/image-spec/blob/master/manifest.md)
ciascuno per una versione specifica dell'architettura di un container. L'idea è che si può avere un unico nome per una stessa immagine (ad esempio: `pause`, `example/mycontainer`, `kube-apiserver`) e permettere a diversi sistemi di recuperare l'immagine binaria corretta a seconda dell'architettura della macchina che la sta utilizzando.
Kubernetes stesso tipicamente nomina le immagini dei container tramite il suffisso `-$(ARCH)`. Per la garantire la retrocompatibilità è meglio generare le vecchie immagini con dei suffissi. L'idea è quella di generare, ad esempio, l'immagine `pause` con un manifest che include tutte le architetture supportate, affiancata, ad esempio, da `pause-amd64` che è retrocompatibile per le vecchie configurazioni o per quei file YAML in cui sono specificate le immagini con i suffissi.
Utilizzare un private registry
------------------------------
I private registry possono richiedere l'utilizzo di chiavi per accedere alle immagini in essi contenute.
Le credenziali possono essere fornite in molti modi:
* configurando i nodi in modo tale da autenticarsi al private registry
* tutti i pod possono acquisire informazioni da qualsiasi private registry configurato
* è necessario che l'amministratore del cluster configuri i nodi in tal senso
* tramite pre-pulled images (immagini pre-caricate sui nodi)
* tutti i pod possono accedere alle immagini salvate sulla cache del nodo a cui si riferiscono
* è necessario effettuare l'accesso come root di sistema su ogni nodo per inserire questa impostazione
* specificando _ImagePullSecrets_ su un determinato pod
* solo i pod che forniscono le proprie chiavi hanno la possibilità di accedere al private registry
* tramite estensioni locali o specifiche di un _Vendor_
* se si sta utilizzando una configurazione personalizzata del nodo oppure se manualmente, o tramite il _cloud provider_, si implementa un meccanismo di autenticazione del nodo presso il _container registry_.
Di seguito la spiegazione dettagliata di queste opzioni.
### Configurazione dei nodi per l'autenticazione ad un private registry
Se si sta utilizzando Docker sui nodi, si può configurare il _Docker container runtime_ per autenticare il nodo presso un private container registry.
Questo è un approccio possibile se si ha il controllo sulle configurazioni del nodo.
#### Nota:
Kubernetes di default supporta solo le sezioni `auths` e `HttpHeaders` nelle configurazioni relative a Docker. Eventuali _helper_ per le credenziali di Docker (`credHelpers` o `credsStore`) non sono supportati.
Docker salva le chiavi per i registri privati in `$HOME/.dockercfg` oppure nel file `$HOME/.docker/config.json`. Inserendo lo stesso file nella lista seguente, kubelet lo utilizzerà per recuperare le credenziali quando deve fare il _pull_ delle immagini.
* `{--root-dir:-/var/lib/kubelet}/config.json`
* `{cwd of kubelet}/config.json`
* `${HOME}/.docker/config.json`
* `/.docker/config.json`
* `{--root-dir:-/var/lib/kubelet}/.dockercfg`
* `{cwd of kubelet}/.dockercfg`
* `${HOME}/.dockercfg`
* `/.dockercfg`
#### Nota:
Potrebbe essere necessario impostare `HOME=/root` esplicitamente come variabile d'ambiente del processo _kubelet_.
Di seguito i passi consigliati per configurare l'utilizzo di un private registry da parte dei nodi del _cluster_. In questo esempio, eseguire i seguenti comandi sul proprio desktop/laptop:
1. Esegui `docker login [server]` per ogni _set_ di credenziali che vuoi utilizzare. Questo comando aggiornerà `$HOME/.docker/config.json` sul tuo PC.
2. Controlla il file `$HOME/.docker/config.json` in un editor di testo per assicurarti che contenga le credenziali che tu voglia utilizzare.
3. Recupera la lista dei tuoi nodi; ad esempio:
* se vuoi utilizzare i nomi: `nodes=$( kubectl get nodes -o jsonpath='{range.items[*].metadata}{.name} {end}' )`
* se vuoi recuperare gli indirizzi IP: `nodes=$( kubectl get nodes -o jsonpath='{range .items[*].status.addresses[?(@.type=="ExternalIP")]}{.address} {end}' )`
4. Copia il tuo file locale `.docker/config.json` in uno dei path sopra riportati nella lista di ricerca.
* ad esempio, per testare il tutto: `for n in $nodes; do scp ~/.docker/config.json root@"$n":/var/lib/kubelet/config.json; done`
#### Nota:
Per i cluster di produzione, utilizza un configuration management tool per poter applicare le impostazioni su tutti i nodi laddove necessario.
Puoi fare una verifica creando un Pod che faccia uso di un'immagine privata; ad esempio:
kubectl apply -f - < --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL
Se possiedi il file delle credenziali per Docker, anziché utilizzare il comando quì sopra puoi importare il file di credenziali come un Kubernetes [Secrets](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-secret "Contiene informazioni sensibili, come passwords, token OAuth, e chiavi ssh.")
.
[Creare un Secret a partire da credenziali Docker](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/#registry-secret-existing-credentials)
fornisce la spiegazione dettagliata su come fare.
Ciò è particolarmente utile se si utilizzano più _container registry_ privati, in quanto il comando `kubectl create secret docker-registry` genera un Secret che funziona con un solo private registry.
#### Nota:
I Pod possono fare riferimento ai Secret per il pull delle immagini soltanto nel proprio _namespace_, quindi questo procedimento deve essere svolto per ogni _namespace_.
#### Fare riferimento ad imagePullSecrets in un Pod
È possibile creare pod che referenzino quel Secret aggiungendo la sezione `imagePullSecrets` alla definizione del Pod.
Ad esempio:
cat < pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: foo
namespace: awesomeapps
spec:
containers:
- name: foo
image: janedoe/awesomeapp:v1
imagePullSecrets:
- name: myregistrykey
EOF
cat <> ./kustomization.yaml
resources:
- pod.yaml
EOF
Questo deve esser fatto per ogni Pod che utilizzi un private registry.
Comunque, le impostazioni relative a questo campo possono essere automatizzate inserendo la sezione _imagePullSecrets_ nella definizione della risorsa [ServiceAccount](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/)
.
Visitare la pagina [Aggiungere ImagePullSecrets ad un Service Account](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#add-imagepullsecrets-to-a-service-account)
per istruzioni più dettagliate.
Puoi utilizzarlo in congiunzione al file `.docker/config.json` configurato per ogni nodo. In questo caso, si applicherà un _merge_ delle credenziali.
Casi d'uso
----------
Ci sono varie soluzioni per configurare i private registry. Di seguito, alcuni casi d'uso comuni e le soluzioni suggerite.
1. Cluster in cui sono utilizzate soltanto immagini non proprietarie (ovvero _open-source_). In questo caso non sussiste il bisogno di nascondere le immagini.
* Utilizza immagini pubbliche da Docker hub.
* Nessuna configurazione richiesta.
* Alcuni _cloud provider_ mettono in _cache_ o effettuano il _mirror_ di immagini pubbliche, il che migliora la disponibilità delle immagini e ne riduce il tempo di _pull_.
2. Cluster con container avviati a partire da immagini proprietarie che dovrebbero essere nascoste a chi è esterno all'organizzazione, ma visibili a tutti gli utenti abilitati nel cluster.
* Utilizza un private [Docker registry](https://docs.docker.com/registry/)
.
* Esso può essere ospitato da [Docker Hub](https://hub.docker.com/signup)
, o da qualche altra piattaforma.
* Configura manualmente il file .docker/config.json su ogni nodo come descritto sopra.
* Oppure, avvia un private registry dietro il tuo firewall con accesso in lettura libero.
* Non è necessaria alcuna configurazione di Kubernetes.
* Utilizza un servizio di _container registry_ che controlli l'accesso alle immagini
* Esso funzionerà meglio con una configurazione del cluster basata su _autoscaling_ che con una configurazione manuale del nodo.
* Oppure, su un cluster dove la modifica delle configurazioni del nodo non è conveniente, utilizza `imagePullSecrets`.
3. Cluster con immagini proprietarie, alcune delle quali richiedono un controllo sugli accessi.
* Assicurati che l'_admission controller_ [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
sia attivo. Altrimenti, tutti i Pod potenzialmente possono avere accesso a tutte le immagini.
* Sposta i dati sensibili un un _Secret_, invece di inserirli in un'immagine.
4. Un cluster multi-tenant dove ogni tenant necessiti di un private registry.
* Assicurati che l'_admission controller_ [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
sia attivo. Altrimenti, tutti i Pod di tutti i tenant potrebbero potenzialmente avere accesso a tutte le immagini.
* Avvia un private registry che richieda un'autorizzazione all'accesso.
* Genera delle credenziali di registry per ogni tenant, inseriscile in dei _Secret_, e popola i _Secret_ per ogni _namespace_ relativo ad ognuno dei tenant.
* Il singolo tenant aggiunge così quel _Secret_ all'impostazione _imagePullSecrets_ di ogni _namespace_.
Se si ha la necessità di accedere a più registri, si può generare un _Secret_ per ognuno di essi. Kubelet farà il _merge_ di ogni `imagePullSecrets` in un singolo file virtuale `.docker/config.json`.
Voci correlate
--------------
* Leggi [OCI Image Manifest Specification](https://github.com/opencontainers/image-spec/blob/master/manifest.md)
2 - Container Environment
=========================
Questa pagina descrive le risorse disponibili nei Container eseguiti in Kubernetes.
Container environment
---------------------
Quando si esegue un Container in Kubernetes, le seguenti risorse sono rese disponibili:
* Un filesystem, composto dal file system dell'[image](https://kubernetes.io/it/docs/concepts/containers/images/)
e da uno o più [volumes](https://kubernetes.io/docs/concepts/storage/volumes/)
.
* Una serie di informazioni sul Container stesso.
* Una serie di informazioni sugli oggetti nel cluster.
### Informazioni sul Container
L' _hostname_ di un Container è il nome del Pod all'interno del quale è eseguito il Container. È consultabile tramite il comando `hostname` o tramite la funzione [`gethostname`](http://man7.org/linux/man-pages/man2/gethostname.2.html)
disponibile in libc.
Il nome del Pod e il namespace possono essere resi disponibili come environment variables attraverso l'uso delle [downward API](https://kubernetes.io/docs/tasks/inject-data-application/downward-api-volume-expose-pod-information/)
.
Gli utenti possono aggiungere altre environment variables nella definizione del Pod; anche queste saranno disponibili nel Container come tutte le altre environment variables definite staticamente nella Docker image.
### Informazioni sul cluster
Al momento della creazione del Container è generata una serie di environment variables con la lista di servizi in esecuzione nel cluster. Queste environment variables rispettano la sintassi dei Docker links.
Per un servizio chiamato _foo_ che è in esecuzione in un Container di nome _bar_, le seguenti variabili sono generate:
FOO_SERVICE_HOST=
FOO_SERVICE_PORT=
I servizi hanno un indirizzo IP dedicato e sono disponibili nei Container anche via DNS se il [DNS addon](http://releases.k8s.io/master/cluster/addons/dns/)
è installato nel cluster.
Voci correlate
--------------
* Approfondisci [Container lifecycle hooks](https://kubernetes.io/it/docs/concepts/containers/container-lifecycle-hooks/)
.
* Esegui un tutorial su come [definire degli handlers per i Container lifecycle events](https://kubernetes.io/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/)
.
3 - Container Lifecycle Hooks
=============================
Questa pagina descrive come i Container gestiti con kubelet possono utilizzare il lifecycle hook framework dei Container per l'esecuzione di codice eseguito in corrispondenza di alcuni eventi durante il loro ciclo di vita.
Overview
--------
Analogamente a molti framework di linguaggi di programmazione che hanno degli hooks legati al ciclo di vita dei componenti, come ad esempio Angular, Kubernetes fornisce ai Container degli hook legati al loro ciclo di vita dei Container. Gli hook consentono ai Container di essere consapevoli degli eventi durante il loro ciclo di gestione ed eseguire del codice implementato in un handler quando il corrispondente hook viene eseguito.
Container hooks
---------------
Esistono due tipi di hook che vengono esposti ai Container:
`PostStart`
Questo hook viene eseguito successivamente alla creazione del container. Tuttavia, non vi è garanzia che questo hook venga eseguito prima dell'ENTRYPOINT del container. Non vengono passati parametri all'handler.
`PreStop`
Questo hook viene eseguito prima della terminazione di un container a causa di una richiesta API o di un evento di gestione, come ad esempio un fallimento delle sonde di liveness/startup, preemption, risorse contese e altro. Una chiamata all'hook di `PreStop` fallisce se il container è in stato terminated o completed e l'hook deve finire prima che possa essere inviato il segnale di TERM per fermare il container. Il conto alla rovescia per la terminazione del Pod (grace period) inizia prima dell'esecuzione dell'hook `PreStop`, quindi indipendentemente dall'esito dell'handler, il container terminerà entro il grace period impostato. Non vengono passati parametri all'handler.
Una descrizione più dettagliata riguardante al processo di terminazione dei Pod può essere trovata in [Terminazione dei Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination)
.
### Implementazione degli hook handler
I Container possono accedere a un hook implementando e registrando un handler per tale hook. Ci sono due tipi di handler che possono essere implementati per i Container:
* Exec - Esegue un comando specifico, tipo `pre-stop.sh`, all'interno dei cgroup e namespace del Container. Le risorse consumate dal comando vengono contate sul Container.
* HTTP - Esegue una richiesta HTTP verso un endpoint specifico del Container.
### Esecuzione dell'hook handler
Quando viene richiamato l'hook legato al lifecycle del Container, il sistema di gestione di Kubernetes esegue l'handler secondo l'azione dell'hook, `httpGet` e `tcpSocket` vengono eseguiti dal processo kubelet, mentre `exec` è eseguito nel Container.
Le chiamate agli handler degli hook sono sincrone rispetto al contesto del Pod che contiene il Container. Questo significa che per un hook `PostStart`, l'ENTRYPOINT e l'hook si attivano in modo asincrono. Tuttavia, se l'hook impiega troppo tempo per essere eseguito o si blocca, il container non può raggiungere lo stato di `running`.
Gli hook di `PreStop` non vengono eseguiti in modo asincrono dall'evento di stop del container; l'hook deve completare la sua esecuzione prima che l'evento TERM possa essere inviato. Se un hook di `PreStop` si blocca durante la sua esecuzione, la fase del Pod rimarrà `Terminating` finchè il Pod non sarà rimosso forzatamente dopo la scadenza del suo `terminationGracePeriodSeconds`. Questo grace period si applica al tempo totale necessario per effettuare sia l'esecuzione dell'hook di `PreStop` che per l'arresto normale del container. Se, per esempio, il `terminationGracePeriodSeconds` è di 60, e l'hook impiega 55 secondi per essere completato, e il container impiega 10 secondi per fermarsi normalmente dopo aver ricevuto il segnale, allora il container verrà terminato prima di poter completare il suo arresto, poiché `terminationGracePeriodSeconds` è inferiore al tempo totale (55+10) necessario perché queste due cose accadano.
Se un hook `PostStart` o `PreStop` fallisce, allora il container viene terminato.
Gli utenti dovrebbero mantenere i loro handler degli hook i più leggeri possibili. Ci sono casi, tuttavia, in cui i comandi di lunga durata hanno senso, come il salvataggio dello stato del container prima della sua fine.
### Garanzia della chiamata dell'hook
La chiamata degli hook avviene _almeno una volta_, il che significa che un hook può essere chiamato più volte da un dato evento, come per `PostStart` o `PreStop`. Sta all'implementazione dell'hook gestire correttamente questo aspetto.
Generalmente, vengono effettuate singole chiamate agli hook. Se, per esempio, la destinazione di hook HTTP non è momentaneamente in grado di ricevere traffico, non c'è alcun tentativo di re invio. In alcuni rari casi, tuttavia, può verificarsi una doppia chiamata. Per esempio, se un kubelet si riavvia nel mentre dell'invio di un hook, questo potrebbe essere chiamato per una seconda volta dopo che il kubelet è tornato in funzione.
### Debugging Hook handlers
I log di un handler di hook non sono esposti negli eventi del Pod. Se un handler fallisce per qualche ragione, trasmette un evento. Per il `PostStart`, questo è l'evento di `FailedPostStartHook`, e per il `PreStop`, questo è l'evento di `FailedPreStopHook`. Puoi vedere questi eventi eseguendo `kubectl describe pod `. Ecco alcuni esempi di output di eventi dall'esecuzione di questo comando:
Events:
FirstSeen LastSeen Count From SubObjectPath Type Reason Message
--------- -------- ----- ---- ------------- -------- ------ -------
1m 1m 1 {default-scheduler } Normal Scheduled Successfully assigned test-1730497541-cq1d2 to gke-test-cluster-default-pool-a07e5d30-siqd
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulling pulling image "test:1.0"
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Created Created container with docker id 5c6a256a2567; Security:[seccomp=unconfined]
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulled Successfully pulled image "test:1.0"
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Started Started container with docker id 5c6a256a2567
38s 38s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 5c6a256a2567: PostStart handler: Error executing in Docker Container: 1
37s 37s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 8df9fdfd7054: PostStart handler: Error executing in Docker Container: 1
38s 37s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} Warning FailedSync Error syncing pod, skipping: failed to "StartContainer" for "main" with RunContainerError: "PostStart handler: Error executing in Docker Container: 1"
1m 22s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Warning FailedPostStartHook
Voci correlate
--------------
* Approfondisci [Container environment](https://kubernetes.io/it/docs/concepts/containers/container-environment/)
.
* Esegui un tutorial su come [definire degli handlers per i Container lifecycle events](https://kubernetes.io/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/)
.
---
# Documentazione di Kubernetes | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/home/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/home/)
.
Documentazione di Kubernetes
============================
* 1: [Versioni supportate della documentazione di Kubernetes](https://kubernetes.io/it/docs/home/_print/#pg-92dfff0ca612d0bff40171aa9df6c4ae)
1 - Versioni supportate della documentazione di Kubernetes
==========================================================
Questo sito contiene la documentazione della versione attuale di Kubernetes e delle quattro versioni precedenti di Kubernetes.
---
# Tutorials | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/tutorials/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/tutorials/)
.
Tutorials
=========
* 1: [Hello Minikube](https://kubernetes.io/it/docs/tutorials/_print/#pg-5e3051fff9e84735871d9fb5e7b93f33)
Questa sezione della documentazione di Kubernetes contiene i tutorials. Un tutorial mostra come raggiungere un obiettivo più complesso di un singolo [task](https://kubernetes.io/docs/tasks/)
. Solitamente un tutorial ha diverse sezioni, ognuna delle quali consiste in una sequenza di più task. Prima di procedere con vari tutorial, raccomandiamo di aggiungere il [Glossario](https://kubernetes.io/it/docs/reference/glossary/)
ai tuoi bookmark per riferimenti successivi.
Per cominciare
--------------
* [Kubernetes Basics](https://kubernetes.io/docs/tutorials/kubernetes-basics/)
è un approfondito tutorial che aiuta a capire cosa è Kubernetes e che permette di testare in modo interattivo alcune semplici funzionalità di Kubernetes.
* [Introduction to Kubernetes (edX)](https://www.edx.org/course/introduction-kubernetes-linuxfoundationx-lfs158x)
* [Hello Minikube](https://kubernetes.io/it/docs/tutorials/hello-minikube/)
Configurazione
--------------
* [Configurare Redis utilizzando una ConfigMap](https://kubernetes.io/docs/tutorials/configuration/configure-redis-using-configmap/)
Stateless Applications
----------------------
* [Esporre un External IP Address per permettere l'accesso alle applicazioni nel Cluster](https://kubernetes.io/docs/tutorials/stateless-application/expose-external-ip-address/)
* [Esempio: Rilasciare l'applicazione PHP Guestbook con Redis](https://kubernetes.io/docs/tutorials/stateless-application/guestbook/)
Stateful Applications
---------------------
* [StatefulSet Basics](https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/)
* [Esempio: WordPress e MySQL con i PersistentVolumes](https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/)
* [Esempio: Rilasciare Cassandra con i StatefulSets](https://kubernetes.io/docs/tutorials/stateful-application/cassandra/)
* [Eseguire ZooKeeper, un sistema distribuito CP](https://kubernetes.io/docs/tutorials/stateful-application/zookeeper/)
Clusters
--------
* [AppArmor](https://kubernetes.io/docs/tutorials/clusters/apparmor/)
* [Seccomp](https://kubernetes.io/docs/tutorials/clusters/seccomp/)
Servizi
-------
* [Utilizzare Source IP](https://kubernetes.io/docs/tutorials/services/source-ip/)
Voci correlate
--------------
Se sei interessato a scrivere un tutorial, vedi [Utilizzare i Page Templates](https://kubernetes.io/docs/home/contribute/page-templates/)
per informazioni su come creare una tutorial page e sul tutorial template.
1 - Hello Minikube
==================
Questo tutorial mostra come eseguire una semplice applicazione in Kubernetes utilizzando [Minikube](https://kubernetes.io/docs/setup/learning-environment/minikube)
e Katacoda. Katacoda permette di operare su un'installazione di Kubernetes dal tuo browser.
#### Nota:
Come alternativa, è possibile eseguire questo tutorial [installando minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/)
localmente.
Obbiettivi
----------
* Rilasciare una semplice applicazione su Minikube.
* Eseguire l'applicazione.
* Visualizzare i log dell'applicazione.
Prima di cominciare
-------------------
Questo tutorial fornisce una container image che utilizza NGINX per risponde a tutte le richieste con un echo che visualizza i dati della richiesta stessa.
Crea un Minikube cluster
------------------------
1. Click **Launch Terminal**
#### Nota:
Se hai installato Minikube localmente, esegui `minikube start`.
2. Apri la console di Kubernetes nel browser:
minikube dashboard
3. Katacoda environment only: In alto alla finestra del terminale, fai click segno più, e a seguire click su **Select port to view on Host 1**.
4. Katacoda environment only: Inserisci `30000`, a seguire click su **Display Port**.
Crea un Deployment
------------------
Un Kubernetes [_Pod_](https://kubernetes.io/docs/concepts/workloads/pods/pod/)
è un gruppo di uno o più Containers, che sono uniti tra loro dal punto di vista amministrativo e che condividono lo stesso network.
Il Pod in questo tutorial ha un solo Container. Un Kubernetes [_Deployment_](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
monitora lo stato del Pod ed eventualmente provvedere a farlo ripartire nel caso questo termini. L'uso dei Deployments è la modalità raccomandata per gestire la creazione e lo scaling dei Pods.
1. Usa il comando `kubectl create` per creare un Deployment che gestisce un singolo Pod. Il Pod eseguirà un Container basato sulla Docker image specificata.
kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.53 -- /agnhost netexec --http-port=8080
2. Visualizza il Deployment:
kubectl get deployments
L'output del comando è simile a:
NAME READY UP-TO-DATE AVAILABLE AGE
hello-node 1/1 1 1 1m
3. Visualizza il Pod creato dal Deployment:
kubectl get pods
L'output del comando è simile a:
NAME READY STATUS RESTARTS AGE
hello-node-5f76cf6ccf-br9b5 1/1 Running 0 1m
4. Visualizza gli eventi del cluster Kubernetes:
kubectl get events
5. Visualizza la configurazione di `kubectl`:
kubectl config view
#### Nota:
Per maggiori informazioni sui comandi di `kubectl`, vedi [kubectl overview](https://kubernetes.io/docs/user-guide/kubectl-overview/)
.
Crea un Service
---------------
Con le impostazioni di default, un Pod è accessibile solamente dagli indirizzi IP interni al Kubernetes cluster. Per far si che il Container `hello-node` sia accessibile dall'esterno del Kubernetes virtual network, è necessario esporre il Pod utilizzando un Kubernetes [_Service_](https://kubernetes.io/docs/concepts/services-networking/service/)
.
1. Esponi il Pod su internet untilizzando il comando `kubectl expose`:
kubectl expose deployment hello-node --type=LoadBalancer --port=8080
Il flag `--type=LoadBalancer` indica la volontà di esporre il Service all'esterno del Kubernetes cluster.
2. Visualizza il Servizio appena creato:
kubectl get services
L'output del comando è simile a:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hello-node LoadBalancer 10.108.144.78 8080:30369/TCP 21s
kubernetes ClusterIP 10.96.0.1 443/TCP 23m
Nei cloud providers che supportano i servizi di tipo load balancers, viene fornito un indirizzo IP pubblico per permettere l'acesso al Service. Su Minikube, il service type `LoadBalancer` rende il Service accessibile attraverso il comando `minikube service`.
3. Esegui il comando:
minikube service hello-node
4. Katacoda environment only: Fai click segno più, e a seguire click su **Select port to view on Host 1**.
5. Katacoda environment only: Fai attenzione al numero di 5 cifre visualizzato a fianco di `8080` nell'output del comando. Questo port number è generato casualmente e può essere diverso nel tuo caso. Inserisci il tuo port number nella textbox, e a seguire fai click su Display Port. Nell'esempio precedente, avresti scritto `30369`.
Questo apre un finestra nel browser dove l'applicazione visuallizza l'echo delle richieste ricevute.
Attiva gli addons
-----------------
Minikube include un set [addons](https://kubernetes.io/it/docs/concepts/cluster-administration/addons/ "Resources that extend the functionality of Kubernetes.")
che possono essere attivati, disattivati o eseguti nel ambiente Kubernetes locale.
1. Elenca gli addons disponibili:
minikube addons list
L'output del comando è simile a:
addon-manager: enabled
dashboard: enabled
default-storageclass: enabled
efk: disabled
freshpod: disabled
gvisor: disabled
helm-tiller: disabled
ingress: disabled
ingress-dns: disabled
logviewer: disabled
metrics-server: disabled
nvidia-driver-installer: disabled
nvidia-gpu-device-plugin: disabled
registry: disabled
registry-creds: disabled
storage-provisioner: enabled
storage-provisioner-gluster: disabled
2. Attiva un addon, per esempio, `metrics-server`:
minikube addons enable metrics-server
L'output del comando è simile a:
metrics-server was successfully enabled
3. Visualizza i Pods ed i Service creati in precedenza:
kubectl get pod,svc -n kube-system
L'output del comando è simile a:
NAME READY STATUS RESTARTS AGE
pod/coredns-5644d7b6d9-mh9ll 1/1 Running 0 34m
pod/coredns-5644d7b6d9-pqd2t 1/1 Running 0 34m
pod/metrics-server-67fb648c5 1/1 Running 0 26s
pod/etcd-minikube 1/1 Running 0 34m
pod/influxdb-grafana-b29w8 2/2 Running 0 26s
pod/kube-addon-manager-minikube 1/1 Running 0 34m
pod/kube-apiserver-minikube 1/1 Running 0 34m
pod/kube-controller-manager-minikube 1/1 Running 0 34m
pod/kube-proxy-rnlps 1/1 Running 0 34m
pod/kube-scheduler-minikube 1/1 Running 0 34m
pod/storage-provisioner 1/1 Running 0 34m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/metrics-server ClusterIP 10.96.241.45 80/TCP 26s
service/kube-dns ClusterIP 10.96.0.10 53/UDP,53/TCP 34m
service/monitoring-grafana NodePort 10.99.24.54 80:30002/TCP 26s
service/monitoring-influxdb ClusterIP 10.111.169.94 8083/TCP,8086/TCP 26s
4. Disabilita `metrics-server`:
minikube addons disable metrics-server
L'output del comando è simile a:
metrics-server was successfully disabled
Clean up
--------
Adesso puoi procedere a fare clean up delle risorse che hai creato nel tuo cluster:
kubectl delete service hello-node
kubectl delete deployment hello-node
Eventualmente, puoi stoppare la Minikube virtual machine (VM):
minikube stop
Eventualmente, puoi cancellare la Minikube VM:
minikube delete
Voci correlate
--------------
* Approfondisci la tua conoscenza dei [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
.
* Approfondisci la tua conoscenza di [Rilasciare applicazioni](https://kubernetes.io/docs/tasks/run-application/run-stateless-application-deployment/)
.
* Approfondisci la tua conoscenza dei [Services](https://kubernetes.io/docs/concepts/services-networking/service/)
.
---
# Manage Cluster Daemons | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/docs/tasks/manage-daemon/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/docs/tasks/manage-daemon/)
.
Manage Cluster Daemons
======================
Perform common tasks for managing a DaemonSet, such as performing a rolling update.
* 1: [Building a Basic DaemonSet](https://kubernetes.io/docs/tasks/manage-daemon/_print/#pg-4c10d304f68febdf95ee7ab4b6b77a96)
* 2: [Perform a Rolling Update on a DaemonSet](https://kubernetes.io/docs/tasks/manage-daemon/_print/#pg-bcfd795e4b59420f7db275a0482af37c)
* 3: [Perform a Rollback on a DaemonSet](https://kubernetes.io/docs/tasks/manage-daemon/_print/#pg-f1bf7e426f482a85e1a417d1fd9ea7b7)
* 4: [Running Pods on Only Some Nodes](https://kubernetes.io/docs/tasks/manage-daemon/_print/#pg-9f4e3502e32b35c9804dd5a30b65b4cc)
1 - Building a Basic DaemonSet
==============================
This page demonstrates how to build a basic [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset "Ensures a copy of a Pod is running across a set of nodes in a cluster.")
that runs a Pod on every node in a Kubernetes cluster. It covers a simple use case of mounting a file from the host, logging its contents using an [init container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/)
, and utilizing a pause container.
Before you begin
----------------
You need to have a Kubernetes cluster, and the kubectl command-line tool must be configured to communicate with your cluster. It is recommended to run this tutorial on a cluster with at least two nodes that are not acting as control plane hosts. If you do not already have a cluster, you can create one by using [minikube](https://minikube.sigs.k8s.io/docs/tutorials/multi_node/)
or you can use one of these Kubernetes playgrounds:
* [iximiuz Labs](https://labs.iximiuz.com/playgrounds?category=kubernetes&filter=all)
* [Killercoda](https://killercoda.com/playgrounds/scenario/kubernetes)
* [KodeKloud](https://kodekloud.com/public-playgrounds)
A Kubernetes cluster with at least two nodes (one control plane node and one worker node) to demonstrate the behavior of DaemonSets.
Define the DaemonSet
--------------------
In this task, a basic DaemonSet is created which ensures that the copy of a Pod is scheduled on every node. The Pod will use an init container to read and log the contents of `/etc/machine-id` from the host, while the main container will be a `pause` container, which keeps the Pod running.
[`application/basic-daemonset.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/application/basic-daemonset.yaml)

apiVersion: apps/v1
kind: DaemonSet
metadata:
name: example-daemonset
spec:
selector:
matchLabels:
app.kubernetes.io/name: example
template:
metadata:
labels:
app.kubernetes.io/name: example
spec:
containers:
- name: pause
image: registry.k8s.io/pause
initContainers:
- name: log-machine-id
image: busybox:1.37
command: ['sh', '-c', 'cat /etc/machine-id > /var/log/machine-id.log']
volumeMounts:
- name: machine-id
mountPath: /etc/machine-id
readOnly: true
- name: log-dir
mountPath: /var/log
volumes:
- name: machine-id
hostPath:
path: /etc/machine-id
type: File
- name: log-dir
hostPath:
path: /var/log
1. Create a DaemonSet based on the (YAML) manifest:
kubectl apply -f https://k8s.io/examples/application/basic-daemonset.yaml
2. Once applied, you can verify that the DaemonSet is running a Pod on every node in the cluster:
kubectl get pods -o wide
The output will list one Pod per node, similar to:
NAME READY STATUS RESTARTS AGE IP NODE
example-daemonset-xxxxx 1/1 Running 0 5m x.x.x.x node-1
example-daemonset-yyyyy 1/1 Running 0 5m x.x.x.x node-2
3. You can inspect the contents of the logged `/etc/machine-id` file by checking the log directory mounted from the host:
kubectl exec -- cat /var/log/machine-id.log
Where `` is the name of one of your Pods.
Cleaning up
-----------
To delete the DaemonSet, run this command:
kubectl delete --cascade=foreground --ignore-not-found --now daemonsets/example-daemonset
This simple DaemonSet example introduces key components like init containers and host path volumes, which can be expanded upon for more advanced use cases. For more details refer to [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)
.
What's next
-----------
* See [Performing a rolling update on a DaemonSet](https://kubernetes.io/docs/tasks/manage-daemon/update-daemon-set/)
* See [Creating a DaemonSet to adopt existing DaemonSet pods](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)
2 - Perform a Rolling Update on a DaemonSet
===========================================
This page shows how to perform a rolling update on a DaemonSet.
Before you begin
----------------
You need to have a Kubernetes cluster, and the kubectl command-line tool must be configured to communicate with your cluster. It is recommended to run this tutorial on a cluster with at least two nodes that are not acting as control plane hosts. If you do not already have a cluster, you can create one by using [minikube](https://minikube.sigs.k8s.io/docs/tutorials/multi_node/)
or you can use one of these Kubernetes playgrounds:
* [iximiuz Labs](https://labs.iximiuz.com/playgrounds?category=kubernetes&filter=all)
* [Killercoda](https://killercoda.com/playgrounds/scenario/kubernetes)
* [KodeKloud](https://kodekloud.com/public-playgrounds)
DaemonSet Update Strategy
-------------------------
DaemonSet has two update strategy types:
* `OnDelete`: With `OnDelete` update strategy, after you update a DaemonSet template, new DaemonSet pods will _only_ be created when you manually delete old DaemonSet pods. This is the same behavior of DaemonSet in Kubernetes version 1.5 or before.
* `RollingUpdate`: This is the default update strategy.
With `RollingUpdate` update strategy, after you update a DaemonSet template, old DaemonSet pods will be killed, and new DaemonSet pods will be created automatically, in a controlled fashion. At most one pod of the DaemonSet will be running on each node during the whole update process.
Performing a Rolling Update
---------------------------
To enable the rolling update feature of a DaemonSet, you must set its `.spec.updateStrategy.type` to `RollingUpdate`.
You may want to set [`.spec.updateStrategy.rollingUpdate.maxUnavailable`](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/daemon-set-v1/#DaemonSetSpec)
(default to 1), [`.spec.minReadySeconds`](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/daemon-set-v1/#DaemonSetSpec)
(default to 0) and [`.spec.updateStrategy.rollingUpdate.maxSurge`](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/daemon-set-v1/#DaemonSetSpec)
(defaults to 0) as well.
### Creating a DaemonSet with `RollingUpdate` update strategy
This YAML file specifies a DaemonSet with an update strategy as 'RollingUpdate'
[`controllers/fluentd-daemonset.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/controllers/fluentd-daemonset.yaml)

apiVersion: apps/v1
kind: DaemonSet
metadata:
name: fluentd-elasticsearch
namespace: kube-system
labels:
k8s-app: fluentd-logging
spec:
selector:
matchLabels:
name: fluentd-elasticsearch
updateStrategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 1
template:
metadata:
labels:
name: fluentd-elasticsearch
spec:
tolerations:
# these tolerations are to have the daemonset runnable on control plane nodes
# remove them if your control plane nodes should not run pods
- key: node-role.kubernetes.io/control-plane
operator: Exists
effect: NoSchedule
- key: node-role.kubernetes.io/master
operator: Exists
effect: NoSchedule
containers:
- name: fluentd-elasticsearch
image: quay.io/fluentd_elasticsearch/fluentd:v5.0.1
volumeMounts:
- name: varlog
mountPath: /var/log
- name: varlibdockercontainers
mountPath: /var/lib/docker/containers
readOnly: true
terminationGracePeriodSeconds: 30
volumes:
- name: varlog
hostPath:
path: /var/log
- name: varlibdockercontainers
hostPath:
path: /var/lib/docker/containers
After verifying the update strategy of the DaemonSet manifest, create the DaemonSet:
kubectl create -f https://k8s.io/examples/controllers/fluentd-daemonset.yaml
Alternatively, use `kubectl apply` to create the same DaemonSet if you plan to update the DaemonSet with `kubectl apply`.
kubectl apply -f https://k8s.io/examples/controllers/fluentd-daemonset.yaml
### Checking DaemonSet `RollingUpdate` update strategy
Check the update strategy of your DaemonSet, and make sure it's set to `RollingUpdate`:
kubectl get ds/fluentd-elasticsearch -o go-template='{{.spec.updateStrategy.type}}{{"\n"}}' -n kube-system
If you haven't created the DaemonSet in the system, check your DaemonSet manifest with the following command instead:
kubectl apply -f https://k8s.io/examples/controllers/fluentd-daemonset.yaml --dry-run=client -o go-template='{{.spec.updateStrategy.type}}{{"\n"}}'
The output from both commands should be:
RollingUpdate
If the output isn't `RollingUpdate`, go back and modify the DaemonSet object or manifest accordingly.
### Updating a DaemonSet template
Any updates to a `RollingUpdate` DaemonSet `.spec.template` will trigger a rolling update. Let's update the DaemonSet by applying a new YAML file. This can be done with several different `kubectl` commands.
[`controllers/fluentd-daemonset-update.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/controllers/fluentd-daemonset-update.yaml)

apiVersion: apps/v1
kind: DaemonSet
metadata:
name: fluentd-elasticsearch
namespace: kube-system
labels:
k8s-app: fluentd-logging
spec:
selector:
matchLabels:
name: fluentd-elasticsearch
updateStrategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 1
template:
metadata:
labels:
name: fluentd-elasticsearch
spec:
tolerations:
# these tolerations are to have the daemonset runnable on control plane nodes
# remove them if your control plane nodes should not run pods
- key: node-role.kubernetes.io/control-plane
operator: Exists
effect: NoSchedule
- key: node-role.kubernetes.io/master
operator: Exists
effect: NoSchedule
containers:
- name: fluentd-elasticsearch
image: quay.io/fluentd_elasticsearch/fluentd:v5.0.1
resources:
limits:
memory: 200Mi
requests:
cpu: 100m
memory: 200Mi
volumeMounts:
- name: varlog
mountPath: /var/log
- name: varlibdockercontainers
mountPath: /var/lib/docker/containers
readOnly: true
terminationGracePeriodSeconds: 30
volumes:
- name: varlog
hostPath:
path: /var/log
- name: varlibdockercontainers
hostPath:
path: /var/lib/docker/containers
#### Declarative commands
If you update DaemonSets using [configuration files](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/declarative-config/)
, use `kubectl apply`:
kubectl apply -f https://k8s.io/examples/controllers/fluentd-daemonset-update.yaml
#### Imperative commands
If you update DaemonSets using [imperative commands](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/imperative-command/)
, use `kubectl edit` :
kubectl edit ds/fluentd-elasticsearch -n kube-system
##### Updating only the container image
If you only need to update the container image in the DaemonSet template, i.e. `.spec.template.spec.containers[*].image`, use `kubectl set image`:
kubectl set image ds/fluentd-elasticsearch fluentd-elasticsearch=quay.io/fluentd_elasticsearch/fluentd:v2.6.0 -n kube-system
### Watching the rolling update status
Finally, watch the rollout status of the latest DaemonSet rolling update:
kubectl rollout status ds/fluentd-elasticsearch -n kube-system
When the rollout is complete, the output is similar to this:
daemonset "fluentd-elasticsearch" successfully rolled out
Troubleshooting
---------------
### DaemonSet rolling update is stuck
Sometimes, a DaemonSet rolling update may be stuck. Here are some possible causes:
#### Some nodes run out of resources
The rollout is stuck because new DaemonSet pods can't be scheduled on at least one node. This is possible when the node is [running out of resources](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/)
.
When this happens, find the nodes that don't have the DaemonSet pods scheduled on by comparing the output of `kubectl get nodes` and the output of:
kubectl get pods -l name=fluentd-elasticsearch -o wide -n kube-system
Once you've found those nodes, delete some non-DaemonSet pods from the node to make room for new DaemonSet pods.
#### Note:
This will cause service disruption when deleted pods are not controlled by any controllers or pods are not replicated. This does not respect [PodDisruptionBudget](https://kubernetes.io/docs/tasks/run-application/configure-pdb/)
either.
#### Broken rollout
If the recent DaemonSet template update is broken, for example, the container is crash looping, or the container image doesn't exist (often due to a typo), DaemonSet rollout won't progress.
To fix this, update the DaemonSet template again. New rollout won't be blocked by previous unhealthy rollouts.
#### Clock skew
If `.spec.minReadySeconds` is specified in the DaemonSet, clock skew between master and nodes will make DaemonSet unable to detect the right rollout progress.
Clean up
--------
Delete DaemonSet from a namespace :
kubectl delete ds fluentd-elasticsearch -n kube-system
What's next
-----------
* See [Performing a rollback on a DaemonSet](https://kubernetes.io/docs/tasks/manage-daemon/rollback-daemon-set/)
* See [Creating a DaemonSet to adopt existing DaemonSet pods](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)
3 - Perform a Rollback on a DaemonSet
=====================================
This page shows how to perform a rollback on a [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset "Ensures a copy of a Pod is running across a set of nodes in a cluster.")
.
Before you begin
----------------
You need to have a Kubernetes cluster, and the kubectl command-line tool must be configured to communicate with your cluster. It is recommended to run this tutorial on a cluster with at least two nodes that are not acting as control plane hosts. If you do not already have a cluster, you can create one by using [minikube](https://minikube.sigs.k8s.io/docs/tutorials/multi_node/)
or you can use one of these Kubernetes playgrounds:
* [iximiuz Labs](https://labs.iximiuz.com/playgrounds?category=kubernetes&filter=all)
* [Killercoda](https://killercoda.com/playgrounds/scenario/kubernetes)
* [KodeKloud](https://kodekloud.com/public-playgrounds)
Your Kubernetes server must be at or later than version 1.7.
To check the version, enter `kubectl version`.
You should already know how to [perform a rolling update on a DaemonSet](https://kubernetes.io/docs/tasks/manage-daemon/update-daemon-set/)
.
Performing a rollback on a DaemonSet
------------------------------------
### Step 1: Find the DaemonSet revision you want to roll back to
You can skip this step if you only want to roll back to the last revision.
List all revisions of a DaemonSet:
kubectl rollout history daemonset
This returns a list of DaemonSet revisions:
daemonsets ""
REVISION CHANGE-CAUSE
1 ...
2 ...
...
* Change cause is copied from DaemonSet annotation `kubernetes.io/change-cause` to its revisions upon creation. You may specify `--record=true` in `kubectl` to record the command executed in the change cause annotation.
To see the details of a specific revision:
kubectl rollout history daemonset --revision=1
This returns the details of that revision:
daemonsets "" with revision #1
Pod Template:
Labels: foo=bar
Containers:
app:
Image: ...
Port: ...
Environment: ...
Mounts: ...
Volumes: ...
### Step 2: Roll back to a specific revision
# Specify the revision number you get from Step 1 in --to-revision
kubectl rollout undo daemonset --to-revision=
If it succeeds, the command returns:
daemonset "" rolled back
#### Note:
If `--to-revision` flag is not specified, kubectl picks the most recent revision.
### Step 3: Watch the progress of the DaemonSet rollback
`kubectl rollout undo daemonset` tells the server to start rolling back the DaemonSet. The real rollback is done asynchronously inside the cluster [control plane](https://kubernetes.io/docs/reference/glossary/?all=true#term-control-plane "The container orchestration layer that exposes the API and interfaces to define, deploy, and manage the lifecycle of containers.")
.
To watch the progress of the rollback:
kubectl rollout status ds/
When the rollback is complete, the output is similar to:
daemonset "" successfully rolled out
Understanding DaemonSet revisions
---------------------------------
In the previous `kubectl rollout history` step, you got a list of DaemonSet revisions. Each revision is stored in a resource named ControllerRevision.
To see what is stored in each revision, find the DaemonSet revision raw resources:
kubectl get controllerrevision -l =
This returns a list of ControllerRevisions:
NAME CONTROLLER REVISION AGE
- DaemonSet/ 1 1h
- DaemonSet/ 2 1h
Each ControllerRevision stores the annotations and template of a DaemonSet revision.
`kubectl rollout undo` takes a specific ControllerRevision and replaces DaemonSet template with the template stored in the ControllerRevision. `kubectl rollout undo` is equivalent to updating DaemonSet template to a previous revision through other commands, such as `kubectl edit` or `kubectl apply`.
#### Note:
DaemonSet revisions only roll forward. That is to say, after a rollback completes, the revision number (`.revision` field) of the ControllerRevision being rolled back to will advance. For example, if you have revision 1 and 2 in the system, and roll back from revision 2 to revision 1, the ControllerRevision with `.revision: 1` will become `.revision: 3`.
Troubleshooting
---------------
* See [troubleshooting DaemonSet rolling update](https://kubernetes.io/docs/tasks/manage-daemon/update-daemon-set/#troubleshooting)
.
4 - Running Pods on Only Some Nodes
===================================
This page demonstrates how can you run [Pods](https://kubernetes.io/docs/concepts/workloads/pods/ "A Pod represents a set of running containers in your cluster.")
on only some [Nodes](https://kubernetes.io/docs/concepts/architecture/nodes/ "A node is a worker machine in Kubernetes.")
as part of a [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset "Ensures a copy of a Pod is running across a set of nodes in a cluster.")
Before you begin
----------------
You need to have a Kubernetes cluster, and the kubectl command-line tool must be configured to communicate with your cluster. It is recommended to run this tutorial on a cluster with at least two nodes that are not acting as control plane hosts. If you do not already have a cluster, you can create one by using [minikube](https://minikube.sigs.k8s.io/docs/tutorials/multi_node/)
or you can use one of these Kubernetes playgrounds:
* [iximiuz Labs](https://labs.iximiuz.com/playgrounds?category=kubernetes&filter=all)
* [Killercoda](https://killercoda.com/playgrounds/scenario/kubernetes)
* [KodeKloud](https://kodekloud.com/public-playgrounds)
Running Pods on only some Nodes
-------------------------------
Imagine that you want to run a [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset "Ensures a copy of a Pod is running across a set of nodes in a cluster.")
, but you only need to run those daemon pods on nodes that have local solid state (SSD) storage. For example, the Pod might provide cache service to the node, and the cache is only useful when low-latency local storage is available.
### Step 1: Add labels to your nodes
Add the label `ssd=true` to the nodes which have SSDs.
kubectl label nodes example-node-1 example-node-2 ssd=true
### Step 2: Create the manifest
Let's create a [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset "Ensures a copy of a Pod is running across a set of nodes in a cluster.")
which will provision the daemon pods on the SSD labeled [nodes](https://kubernetes.io/docs/concepts/architecture/nodes/ "A node is a worker machine in Kubernetes.")
only.
Next, use a `nodeSelector` to ensure that the DaemonSet only runs Pods on nodes with the `ssd` label set to `"true"`.
[`controllers/daemonset-label-selector.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/controllers/daemonset-label-selector.yaml)

apiVersion: apps/v1
kind: DaemonSet
metadata:
name: ssd-driver
labels:
app: nginx
spec:
selector:
matchLabels:
app: ssd-driver-pod
template:
metadata:
labels:
app: ssd-driver-pod
spec:
nodeSelector:
ssd: "true"
containers:
- name: example-container
image: example-image
### Step 3: Create the DaemonSet
Create the DaemonSet from the manifest by using `kubectl create` or `kubectl apply`
Let's label another node as `ssd=true`.
kubectl label nodes example-node-3 ssd=true
Labelling the node automatically triggers the control plane (specifically, the DaemonSet controller) to run a new daemon pod on that node.
kubectl get pods -o wide
The output is similar to:
NAME READY STATUS RESTARTS AGE IP NODE
1/1 Running 0 13s ..... example-node-1
1/1 Running 0 13s ..... example-node-2
1/1 Running 0 5s ..... example-node-3
---
# नीतियाँ | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/concepts/policy/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/concepts/policy/)
.
नीतियाँ
=======
नीतियों के साथ सुरक्षा और सर्वोत्तम प्रथाओं को प्रबंधित करें।
Kubernetes नीतियाँ वे कॉन्फ़िगरेशन होती हैं जो अन्य कॉन्फ़िगरेशन या रनटाइम व्यवहारों को प्रबंधित करती हैं। Kubernetes विभिन्न प्रकार की नीतियाँ प्रदान करता है, जो नीचे दी गई हैं:
API ऑब्जेक्ट्स का उपयोग करके नीतियाँ लागू करें
----------------------------------------------
कुछ API ऑब्जेक्ट्स नीतियों के रूप में कार्य करते हैं। यहाँ कुछ उदाहरण दिए गए हैं:
* [NetworkPolicies](https://kubernetes.io/docs/concepts/services-networking/network-policies/)
का उपयोग किसी वर्कलोड के लिए इनग्रेस और एग्रेस ट्रैफिक को प्रतिबंधित करने के लिए किया जा सकता है।
* [LimitRanges](https://kubernetes.io/docs/concepts/policy/limit-range/)
विभिन्न ऑब्जेक्ट प्रकारों के बीच संसाधन आवंटन सीमाओं का प्रबंधन करते हैं।
* [ResourceQuotas](https://kubernetes.io/docs/concepts/policy/resource-quotas/)
किसी [नेमस्पेस](https://kubernetes.io/hi/docs/concepts/overview/working-with-objects/namespaces "An abstraction used by Kubernetes to support isolation of groups of resources within a single cluster.")
के लिए संसाधन खपत को सीमित करती हैं।
Admission Controllers का उपयोग करके नीतियाँ लागू करें
-----------------------------------------------------
एक [admission controller](https://kubernetes.io/hi/docs/reference/access-authn-authz/admission-controllers/ "कोड का एक भाग जो ऑब्जेक्ट के स्थायी रूप से संग्रहीत होने से पहले कुबेरनेट्स API सर्वर को भेजे गए अनुरोधों को इंटरसेप्ट करता है।")
API सर्वर में चलता है और API अनुरोधों को सत्यापित या बदल सकता है। कुछ admission controllers नीतियों को लागू करने के लिए कार्य करते हैं। उदाहरण के लिए, [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
admission controller प्रत्येक नए Pod में इमेज पुल नीति को `Always` पर सेट करने के लिए सक्षम करता है।
Kubernetes के पास कई अंतर्निहित admission controllers हैं जिन्हें API सर्वर `--enable-admission-plugins` फ्लैग के माध्यम से कॉन्फ़िगर किया जा सकता है।
Admission controllers के बारे में विस्तृत जानकारी, उपलब्ध admission controllers की पूरी सूची के साथ, एक समर्पित अनुभाग में प्रलेखित है:
* [Admission Controllers](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)
ValidatingAdmissionPolicy का उपयोग करके नीतियाँ लागू करें
---------------------------------------------------------
Validating admission policies, API सर्वर में कॉन्फ़िगर करने योग्य सत्यापन जांचों को लागू करने की अनुमति देती हैं, जो Common Expression Language (CEL) का उपयोग करती हैं। उदाहरण के लिए, एक `ValidatingAdmissionPolicy` का उपयोग `latest` इमेज टैग के उपयोग को अस्वीकृत करने के लिए किया जा सकता है।
एक `ValidatingAdmissionPolicy` एक API अनुरोध पर कार्य करता है और गैर-अनुपालन कॉन्फ़िगरेशनों के बारे में उपयोगकर्ताओं को ब्लॉक, ऑडिट, और चेतावनी देने के लिए उपयोग किया जा सकता है।
`ValidatingAdmissionPolicy` API के बारे में विवरण, उदाहरणों सहित, एक समर्पित अनुभाग में प्रलेखित है:
* [Validating Admission Policy](https://kubernetes.io/docs/reference/access-authn-authz/validating-admission-policy/)
Dynamic admission control का उपयोग करके नीतियाँ लागू करें
---------------------------------------------------------
Dynamic admission controllers (या admission webhooks) API सर्वर के बाहर एक अलग एप्लिकेशन के रूप में चलते हैं जो API अनुरोधों के सत्यापन या संशोधन के लिए वेबहुक अनुरोधों को प्राप्त करने के लिए पंजीकृत होते हैं।
Dynamic admission controllers का उपयोग API अनुरोधों पर नीतियाँ लागू करने और अन्य नीति-आधारित वर्कफ़्लोज़ को ट्रिगर करने के लिए किया जा सकता है। एक dynamic admission controller ऐसी जटिल जांच कर सकता है, जिसमें अन्य क्लस्टर संसाधनों और बाहरी डेटा की पुनर्प्राप्ति की आवश्यकता होती है। उदाहरण के लिए, एक इमेज सत्यापन जांच OCI रजिस्ट्रियों से डेटा प्राप्त करके कंटेनर इमेज हस्ताक्षर और प्रमाणपत्रों को मान्य करने के लिए उपयोग की जा सकती है।
Dynamic admission control के बारे में विवरण एक समर्पित अनुभाग में प्रलेखित है:
* [Dynamic Admission Control](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/)
### Implementations
**टिप्पणी:** यह खंड अन्य पक्ष परियोजनाओं से जुड़ा है जो कुबेरनेट्स द्वारा आवश्यक कार्यक्षमता प्रदान करते हैं। कुबेरनेट्स परियोजना के लेखक इन परियोजनाओं के लिए जिम्मेदार नहीं हैं। यह पृष्ठ [CNCF वेबसाइट दिशानिर्देश](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
का अनुसरण करते हुए परियोजनाओं को वर्णानुक्रम में सूचीबद्ध करता है। इस सूची में कोई नई परियोजना जोड़ने से पहले यह [विषय मार्गदर्शक](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
पृष्ट पढ़के ही परिवर्तन करें।
Dynamic admission controllers जो फ्लेक्सिबल नीति इंजन के रूप में कार्य करते हैं, उन्हें कुबेरनेट्स इकोसिस्टम में विकसित किया जा रहा है, जैसे की:
* [Kubewarden](https://github.com/kubewarden)
* [Kyverno](https://kyverno.io/)
* [OPA Gatekeeper](https://github.com/open-policy-agent/gatekeeper)
* [Polaris](https://polaris.docs.fairwinds.com/admission-controller/)
Kubelet कॉन्फ़िगरेशनों का उपयोग करके नीतियाँ लागू करें
------------------------------------------------------
Kubernetes प्रत्येक वर्कर नोड पर Kubelet को कॉन्फ़िगर करने की अनुमति देता है। कुछ Kubelet कॉन्फ़िगरेशन नीतियों के रूप में कार्य करते हैं:
* [Process ID limits and reservations](https://kubernetes.io/docs/concepts/policy/pid-limiting/)
का उपयोग आवंटन योग्य PIDs को सीमित और आरक्षित करने के लिए किया जाता है।
* [Node Resource Managers](https://kubernetes.io/docs/concepts/policy/node-resource-managers/)
उच्च-प्रदर्शन और विलंब-संवेदनशील वर्कलोड्स के लिए कंप्यूट, मेमोरी, और डिवाइस संसाधनों का प्रबंधन कर सकते हैं।
---
# Other Tools | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/docs/reference/tools/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/docs/reference/tools/)
.
Other Tools
===========
Kubernetes contains several tools to help you work with the Kubernetes system.
crictl
------
[`crictl`](https://github.com/kubernetes-sigs/cri-tools)
is a command-line interface for inspecting and debugging [CRI](https://kubernetes.io/docs/concepts/architecture/cri "Protocol for communication between the kubelet and the local container runtime.")
\-compatible container runtimes.
Dashboard
---------
[`Dashboard`](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)
, the web-based user interface of Kubernetes, allows you to deploy containerized applications to a Kubernetes cluster, troubleshoot them, and manage the cluster and its resources itself.
Headlamp
--------
[Headlamp](https://headlamp.dev/)
is an extensible Kubernetes graphical user interface, and is an optional Kubernetes cluster component. Headlamp is part of the Kubernetes project.
Headlamp provides:
* A modern, user-friendly graphical interface for cluster management and troubleshooting
* Support for both in-cluster deployment and desktop application modes
* Extensibility through a plugin system
* RBAC-based controls that adapt to user permissions
Helm
----
🛇 This item links to a third party project or product that is not part of Kubernetes itself. [More information](https://kubernetes.io/docs/reference/tools/_print/#third-party-content-disclaimer)
[Helm](https://helm.sh/)
is a tool for managing packages of pre-configured Kubernetes resources. These packages are known as _Helm charts_.
Use Helm to:
* Find and use popular software packaged as Kubernetes charts
* Share your own applications as Kubernetes charts
* Create reproducible builds of your Kubernetes applications
* Intelligently manage your Kubernetes manifest files
* Manage releases of Helm packages
Kompose
-------
[`Kompose`](https://github.com/kubernetes/kompose)
is a tool to help Docker Compose users move to Kubernetes.
Use Kompose to:
* Translate a Docker Compose file into Kubernetes objects
* Go from local Docker development to managing your application via Kubernetes
* Convert v1 or v2 Docker Compose `yaml` files or [Distributed Application Bundles](https://docs.docker.com/compose/bundles/)
Kui
---
[`Kui`](https://github.com/kubernetes-sigs/kui)
is a GUI tool that takes your normal `kubectl` command line requests and responds with graphics. Instead of ASCII tables, Kui provides a GUI rendering with tables that you can sort.
Kui lets you:
* Directly click on long, auto-generated resource names instead of copying and pasting
* Type in `kubectl` commands and see them execute, even sometimes faster than `kubectl` itself
* Query a [Job](https://kubernetes.io/docs/concepts/workloads/controllers/job/ "A finite or batch task that runs to completion.")
and see its execution rendered as a waterfall diagram
* Click through resources in your cluster using a tabbed UI
Minikube
--------
[`minikube`](https://minikube.sigs.k8s.io/docs/)
is a tool that runs a single-node Kubernetes cluster locally on your workstation for development and testing purposes.
---
# उत्पादन वातावरण | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/setup/production-environment/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/setup/production-environment/)
.
उत्पादन वातावरण
===============
एक उत्पादन-गुणवत्ता वाला कुबेरनेट्स क्लस्टर बनाएं
* 1: [कंटेनर रनटाइम](https://kubernetes.io/hi/docs/setup/production-environment/_print/#pg-a77d3feb6e6d9978f32fa14622642e9a)
* 2: [Turnkey Cloud Solutions](https://kubernetes.io/hi/docs/setup/production-environment/_print/#pg-d2f55eefe7222b7c637875af9c3ec199)
* 3: [परिनियोजन टूल के साथ कुबेरनेट्स स्थापित करे](https://kubernetes.io/hi/docs/setup/production-environment/_print/#pg-00e1646f68aeb89f9722cf6f6cfcad94)
* 4: [कुबेरनेट्स में Windows](https://kubernetes.io/hi/docs/setup/production-environment/_print/#pg-acce7e24090fea04715a7a516ba3e69b)
उत्पादन-गुणवत्ता वाले कुबेरनेट्स क्लस्टर के लिए योजना और तैयारी की आवश्यकता होती है। यदि आपका कुबेरनेट्स क्लस्टर महत्वपूर्ण कार्यभार चलाने के लिए है, तो इसे लचीला होने के लिए कॉन्फ़िगर किया जाना चाहिए। यह पेज उन चरणों के बारे में बताता है जो आप उत्पादन के लिए तैयार क्लस्टर सेटअप करने के लिए, या उत्पादन के उपयोग के लिए मौजूदा क्लस्टर को अपग्रेड करने के लिए उठा सकते हैं। यदि आप पहले से ही उत्पादन सेटअप से परिचित हैं और लिंक चाहते हैं, तो [आगे जाएं](https://kubernetes.io/hi/docs/setup/production-environment/_print/#what-s-next)
।
उत्पादन विचार
-------------
आमतौर पर, उत्पादन कुबेरनेट्स क्लस्टर वातावरण में व्यक्तिगत सीखने, विकास या परीक्षण वातावरण कुबेरनेट्स की तुलना में अधिक आवश्यकताएं होती हैं। एक उत्पादन वातावरण की आवश्यकता ये हो सकती है, जैसे: कई उपयोगकर्ताओं द्वारा सुरक्षित पहुंच, लगातार उपलब्धता, और बदलती मांगों के लिए संसाधनों को अनुकूलित करना।
जैसा कि आप तय करते हैं कि आप अपने उत्पादन कुबेरनेट्स वातावरण को कहाँ रखना चाहते हैं (परिसर या क्लाउड में) और प्रबंधन की मात्रा जिसे आप दूसरों को देना या सौंपना चाहते हैं, विचार करें कि कुबेरनेट्स क्लस्टर के लिए आपकी आवश्यकताएं निम्नलिखित मुद्दों से कैसे प्रभावित होती हैं:
* _उपलब्धता_: सिंगल-मशीन कुबेरनेट्स [सीखने का माहौल](https://kubernetes.io/hi/docs/setup/#learning-environment)
में विफलता का एक बिंदु है। अत्यधिक उपलब्ध क्लस्टर बनाने का अर्थ है:
* कण्ट्रोल प्लेन को वर्कर नोड्स से अलग करना।
* कई नोड्स पर कण्ट्रोल प्लेन घटकों की प्रतिकृति।
* क्लस्टर के लिए संतुलन यातायात लोड करें[API server](https://kubernetes.io/hi/docs/concepts/overview/components/#kube-apiserver "एक कंट्रोल प्लेन घटक जो कुबेरनेट्स API की सेवाएं प्रदान करता है।।")
.
* पर्याप्त वर्कर नोड्स उपलब्ध होना, या जल्दी से उपलब्ध होने में सक्षम होना, क्योंकि बदलते वर्कलोड इसे वारंट करते हैं।
* _स्केल_: यदि आप उम्मीद करते हैं कि आपके उत्पादन कुबेरनेट्स पर्यावरण को मांग की एक स्थिर मात्रा प्राप्त होगी, तो आप उस क्षमता के लिए सेटअप करने में सक्षम हो सकते हैं जिसकी आपको आवश्यकता है और किया जा सकता है। हालाँकि, यदि आप समय के साथ मांग बढ़ने की उम्मीद करते हैं या मौसम या विशेष घटनाओं जैसी चीजों के आधार पर अचानक से बदलते हैं, तो आपको योजना बनाने की आवश्यकता है कि कण्ट्रोल प्लेन और वर्कर नोड्स के लिए अधिक अनुरोधों से बढ़े दबाव को कैसे दूर किया जाए या अप्रयुक्त संसाधनों को कम करने के लिए स्केल किया जाए।
* _सुरक्षा और एक्सेस मैनेजमेंट_: आपके अपने कुबेरनेट्स लर्निंग क्लस्टर पर पूर्ण व्यवस्थापकीय विशेषाधिकार हैं। लेकिन महत्वपूर्ण कार्यभार के साथ साझा क्लस्टर, और एक या दो से अधिक उपयोगकर्ता, को क्लस्टर संसाधनों तक कौन और क्या एक्सेस कर सकता है, इसके लिए अधिक परिष्कृत दृष्टिकोण की आवश्यकता होती है। आप यह सुनिश्चित करने के लिए ([भूमिका-आधारित एक्सेस कण्ट्रोल](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)
) और अन्य सुरक्षा तंत्रों का उपयोग कर सकते हैं कि उपयोगकर्ता और कार्यभार उन संसाधनों तक पहुँच प्राप्त कर सकते हैं जिनकी उन्हें आवश्यकता है, साथ ही में कार्यभार और क्लस्टर को साथ में सुरक्षित रख सके। आप [नीतियों](https://kubernetes.io/hi/docs/concepts/policy/)
और [कंटेनर संसाधन](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
को प्रबंधित करके उन संसाधनों की सीमा निर्धारित कर सकते हैं जिन तक उपयोगकर्ता और कार्यभार पहुंच सकते हैं।
कुबेरनेट्स उत्पादन वातावरण को स्वयं बनाने से पहले, इस कार्य में से कुछ या सभी को सौंपने पर विचार करें [टर्नकी क्लाउड सॉल्यूशंस](https://kubernetes.io/hi/docs/setup/production-environment/turnkey-solutions/)
प्रदाता या अन्य [कुबेरनेट्स पार्टनर्स](https://kubernetes.io/partners/)
विकल्पों में शामिल हैं:
* _सर्वरलेस_: किसी क्लस्टर को प्रबंधित किए बिना केवल तृतीय-पक्ष उपकरण पर कार्यभार चलाएं। आपसे सीपीयू उपयोग, मेमोरी और डिस्क अनुरोध जैसी चीज़ों के लिए शुल्क लिया जाएगा।
* _व्यवस्थित कण्ट्रोल प्लेन_: प्रदाता को क्लस्टर के कण्ट्रोल प्लेन के पैमाने और उपलब्धता का प्रबंधन करने दें, साथ ही पैच और अपग्रेड को भी संभालें।
* _व्यवस्थित वर्कर नोड्स_: अपनी आवश्यकताओं को पूरा करने के लिए नोड्स के पूल को कॉन्फ़िगर करें, फिर प्रदाता सुनिश्चित करता है कि वे नोड उपलब्ध हैं और जरूरत पड़ने पर अपग्रेड को लागू करने के लिए तैयार हैं।
* _एकीकरण_: ऐसे प्रदाता हैं जो कुबेरनेट्स को अन्य सेवाओं के साथ एकीकृत करते हैं जिनकी आपको आवश्यकता हो सकती है, जैसे भंडारण, कंटेनर रजिस्ट्रियां, प्रमाणीकरण तरीके, और विकास उपकरण।
चाहे आप कुबेरनेट्स क्लस्टर का निर्माण स्वयं करें या भागीदारों के साथ काम करें, अपनी आवश्यकताओं का मूल्यांकन करने के लिए निम्नलिखित अनुभागों की समीक्षा करें क्योंकि वे आपके क्लस्टर से संबंधित हैं _कण्ट्रोल प्लेन_, _वर्कर नोड्स_, _यूज़र एक्सेस_, और _वर्कलोड रिसोर्सस_.
उत्पादन क्लस्टर सेटअप
---------------------
उत्पादन-गुणवत्ता वाले कुबेरनेट्स क्लस्टर में, कण्ट्रोल प्लेन क्लस्टर को उन सेवाओं से प्रबंधित करता है जिन्हें विभिन्न तरीकों से कई कंप्यूटरों में फैलाया जा सकता है। हालाँकि, प्रत्येक वर्कर नोड एक एकल इकाई का प्रतिनिधित्व करता है जिसे कुबेरनेट्स पॉड चलाने के लिए कॉन्फ़िगर किया गया है।
### उत्पादन कण्ट्रोल प्लेन
सबसे सरल कुबेरनेट्स क्लस्टर में एक ही मशीन पर चलने वाले संपूर्ण कण्ट्रोल प्लेन और वर्कर नोड सेवाएं होती हैं। आप वर्कर नोड्स को जोड़कर उस वातावरण को विकसित कर सकते हैं, जैसा कि [कुबेरनेट्स कंपोनेंट्स](https://kubernetes.io/docs/concepts/overview/components/)
के डायग्राम में दर्शाया गया है। यदि क्लस्टर थोड़े समय के लिए उपलब्ध होने के लिए है, या अगर कुछ गंभीर रूप से गलत हो जाता है, तो इसे छोड़ दिया जा सकता है, यह आपकी आवश्यकताओं को पूरा कर सकता है।
यदि आपको अधिक स्थायी, अत्यधिक उपलब्ध क्लस्टर की आवश्यकता है, तो आपको कण्ट्रोल प्लेन को विस्तारित करने के तरीकों पर विचार करना चाहिए। डिजाइन के अनुसार, एक मशीन पर चलने वाली एक-मशीन कण्ट्रोल प्लेन सेवाएं अत्यधिक उपलब्ध नहीं हैं। यदि क्लस्टर को चालू रखना और यह सुनिश्चित करना कि कुछ गलत होने पर इसकी मरम्मत की जा सकती है, महत्वपूर्ण है, तो इन चरणों पर विचार करें:
* _डिप्लॉयमेंट टूल्स चुनें_: आप kubeadm, kops, और kubespray जैसे टूल का उपयोग करके एक कण्ट्रोल प्लेन को तैनात कर सकते हैं। उनमें से प्रत्येक डिप्लॉयमेंट विधियों का उपयोग करके उत्पादन-गुणवत्ता डिप्लॉयमेंट के लिए युक्तियों को जानने के लिए [डिप्लॉयमेंट टूल्स के साथ कुबेरनेट्स स्थापित करना](https://kubernetes.io/hi/docs/setup/production-environment/tools/)
देखें। आपके डिप्लॉयमेंट के साथ उपयोग करने के लिए विभिन्न [कंटेनर रनटाइम](https://kubernetes.io/hi/docs/setup/production-environment/container-runtimes/)
उपलब्ध हैं।
* _सर्टिफ़िकेट प्रबंधित करे_: कण्ट्रोल प्लेन सेवाओं के बीच सुरक्षित संचार सर्टिफ़िकेटस का उपयोग करके कार्यान्वित किया जाता है। डिप्लॉयमेंट के दौरान सर्टिफ़िकेट स्वचालित रूप से उत्पन्न होते हैं या आप अपने स्वयं के सर्टिफ़िकेट अथॉरिटी का उपयोग करके उन्हें उत्पन्न कर सकते हैं। विवरण के लिए [PKI सर्टिफ़िकेटस और आवश्यकताएं](https://kubernetes.io/docs/setup/best-practices/certificates/)
देखें।
* _एपिसर्वर के लिए लोड बैलेंसर कॉन्फ़िगर करें_: विभिन्न नोड्स पर चल रहे एपिसर्वर सर्विस इंस्टेंस के लिए बाहरी एपीआई अनुरोधों को वितरित करने के लिए लोड बैलेंसर को कॉन्फ़िगर करें। विवरण के लिए [एक बाहरी लोड बैलेंसर बनाना](https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/)
देखें।
* _अलग और बैकअप etcd सेवा_: अतिरिक्त सुरक्षा और उपलब्धता के लिए etcd सेवाएं या तो अन्य कंट्रोल प्लेन सेवाओं के समान मशीनों पर चल सकती हैं या अलग मशीनों पर चल सकती हैं। क्योंकि etcd क्लस्टर कॉन्फ़िगरेशन डेटा संग्रहीत करता है, etcd डेटाबेस का बैकअप नियमित रूप से किया जाना चाहिए ताकि यह सुनिश्चित हो सके कि यदि आवश्यक हो तो आप उस डेटाबेस की मरम्मत कर सकते हैं। etcd को कॉन्फ़िगर करने और उपयोग करने के विवरण के लिए [etcd अक्सर पूछे जाने वाले प्रश्न](https://etcd.io/docs/v3.5/faq/)
देखें। विवरण के लिए [कुबेरनेट्स के लिए ऑपरेटिंग etcd क्लस्टर](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/)
और [क्यूबएडीएम के साथ एक उच्च उपलब्धता etcd क्लस्टर स्थापित करें](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm/)
देखें।
* _मल्टीपल कण्ट्रोल प्लेन सिस्टम बनाएं_: उच्च उपलब्धता के लिए, कण्ट्रोल प्लेन एक मशीन तक सीमित नहीं होना चाहिए। यदि कण्ट्रोल प्लेन सेवाएं एक init सेवा (जैसे systemd) द्वारा चलाई जाती हैं, तो प्रत्येक सेवा को कम से कम तीन मशीनों पर चलना चाहिए। हालाँकि, कुबेरनेट्स में पॉड्स के रूप में कण्ट्रोल प्लेन सेवाएं चलाना सुनिश्चित करता है कि आपके द्वारा अनुरोधित सेवाओं की प्रतिकृति संख्या हमेशा उपलब्ध रहेगी। अनुसूचक फॉल्ट सहने वाला होना चाहिए, लेकिन अत्यधिक उपलब्ध नहीं होना चाहिए। कुबेरनेट्स सेवाओं के नेता चुनाव करने के लिए कुछ डिप्लॉयमेंट उपकरण [राफ्ट](https://raft.github.io/)
सर्वसम्मति एल्गोरिथ्म की स्थापना करते हैं। यदि प्राथमिक चला जाता है, तो दूसरी सेवा स्वयं को चुनती है और कार्यभार संभालती है।
* _कई क्षेत्रों में विस्तार करना_: यदि अपने क्लस्टर को हर समय उपलब्ध रखना महत्वपूर्ण है, तो एक ऐसा क्लस्टर बनाने पर विचार करें, जो कई डेटा केंद्रों पर चलता हो, जिसे क्लाउड वातावरण में ज़ोन के रूप में संदर्भित किया जाता है। ज़ोन(zone) के समूहों को रीजन(region) कहा जाता है। एक ही क्षेत्र में कई क्षेत्रों में एक क्लस्टर फैलाकर, यह इस संभावना में सुधार कर सकता है कि एक क्षेत्र अनुपलब्ध होने पर भी आपका क्लस्टर कार्य करना जारी रखेगा। विवरण के लिए [एक से अधिक ज़ोन मे चलाना](https://kubernetes.io/docs/setup/best-practices/multiple-zones/)
देखें।
* _चल रही सुविधाओं का प्रबंधन_: यदि आप अपने क्लस्टर को समय के साथ रखने की योजना बनाते हैं, तो इसके स्वास्थ्य और सुरक्षा को बनाए रखने के लिए आपको कुछ कार्य करने होंगे। उदाहरण के लिए, यदि आपने क्यूबएडीएम के साथ स्थापित किया है, तो आपको [सर्टिफिकेट प्रबंधन](https://kubernetes.io/docs/tasks/administer-cluster/kubeadm/kubeadm-certs/)
और [क्यूबएडीएम क्लस्टर्स को अपग्रेड करने](https://kubernetes.io/docs/tasks/administer-cluster/kubeadm/kubeadm-upgrade/)
में मदद करने के लिए निर्देश दिए गए हैं, कुबेरनेट्स प्रशासनिक कार्यों की लंबी सूची के लिए [क्लस्टर का एडमिनिस्टर](https://kubernetes.io/docs/tasks/administer-cluster/)
देखें।
जब आप कण्ट्रोल प्लेन सेवाएं चलाते हैं, तो उपलब्ध विकल्पों के बारे में जानने के लिए, [kube-apiserver](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/)
, [क्यूब-कंट्रोलर-मैनेजर](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-controller-manager/)
, देखें। और [क्यूब-शेड्यूलर](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-scheduler/)
कॉम्पोनेन्ट पेज। अत्यधिक उपलब्ध कंट्रोल प्लेन उदाहरणों के लिए [अत्यधिक उपलब्ध टोपोलॉजी के लिए विकल्प](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/ha-topology/)
, [kubeadm के साथ अत्यधिक उपलब्ध क्लस्टर बनाना](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/)
, और [कुबेरनेट्स के लिए ऑपरेटिंग etcd क्लस्टर](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/)
। etcd बैकअप योजना बनाने के बारे में जानकारी के लिए [etcd क्लस्टर का बैकअप लेना](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/#backing-up-an-etcd-cluster)
देखें।
### उत्पादन वर्कर नोड्स
उत्पादन-गुणवत्ता वाले कार्यभार को लचीला होने की आवश्यकता है और वे जिस चीज पर भरोसा करते हैं वह लचीला होना चाहिए (जैसे कि CoreDNS)। चाहे आप अपने स्वयं के कंट्रोल प्लेन का प्रबंधन करें या क्लाउड प्रदाता आपके लिए इसे करें, आपको अभी भी यह विचार करने की आवश्यकता है कि आप अपने वर्कर नोड्स को कैसे प्रबंधित करना चाहते हैं (इसे बस _नोड्स_ के रूप में भी संदर्भित किया गया है)।
* _नोड्स कॉन्फ़िगर करें_: नोड्स भौतिक या आभासी मशीन हो सकते हैं। यदि आप अपने स्वयं के नोड्स बनाना और प्रबंधित करना चाहते हैं, तो आप एक समर्थित ऑपरेटिंग सिस्टम स्थापित कर सकते हैं, फिर उपयुक्त जोड़ और चला सकते हैं [नोड सेवाएं](https://kubernetes.io/docs/concepts/overview/components/#node-components)
। विचार करना:
* जब आप उपयुक्त मेमोरी, सीपीयू, और डिस्क स्पीड और स्टोरेज क्षमता उपलब्ध कराकर नोड्स सेट करते हैं तो आपके वर्कलोड की मांग।
* क्या जेनेरिक कंप्यूटर सिस्टम करेंगे या आपके पास ऐसे वर्कलोड हैं जिन्हें GPU प्रोसेसर, Windows नोड्स या VM आइसोलेशन की आवश्यकता है।
* _वैलिदेट(Validate) नोड_: यह सुनिश्चित करने के तरीके के बारे में जानकारी के लिए [वैलिद(Valid) नोड सेटअप](https://kubernetes.io/docs/setup/best-practices/node-conformance/)
देखें कि एक नोड कुबेरनेट्स क्लस्टर में शामिल होने के लिए आवश्यकताओं को पूरा करता है।
* _क्लस्टर में नोड जोड़ें_: यदि आप अपने स्वयं के क्लस्टर का प्रबंधन कर रहे हैं, तो आप अपनी स्वयं की मशीनें स्थापित करके और या तो उन्हें मैन्युअल रूप से जोड़कर या क्लस्टर के एपिसर्वर में खुद को पंजीकृत करवाकर नोड्स जोड़ सकते हैं। इन तरीकों से नोड्स जोड़ने के लिए कुबेरनेट्स को कैसे सेट करें, इस बारे में जानकारी के लिए [नोड्स](https://kubernetes.io/docs/concepts/architecture/nodes/)
अनुभाग देखें।
* _क्लस्टर में Windows नोड्स जोड़ें_: कुबेरनेट्स Windows वर्कर नोड्स के लिए समर्थन प्रदान करता है, जिससे आप Windows कंटेनरों में लागू वर्कलोड को चला सकते हैं। विवरण के लिए [कुबेरनेट्स में Windows](https://kubernetes.io/hi/docs/setup/production-environment/windows/)
देखें।
* _स्केल नोड्स_: आपके क्लस्टर को अंततः जिस क्षमता की आवश्यकता होगी, उसके विस्तार के लिए एक योजना बनाएं। आपको चलाने के लिए आवश्यक पॉड्स और कंटेनरों की संख्या के आधार पर, यह निर्धारित करने में सहायता के लिए [बड़े समूहों के लिए विचार](https://kubernetes.io/docs/setup/best-practices/cluster-large/)
देखें कि आपको कितने नोड्स की आवश्यकता है। यदि आप स्वयं नोड्स का प्रबंधन कर रहे हैं, तो इसका अर्थ यह हो सकता है कि आप अपने स्वयं के भौतिक उपकरण खरीदना और स्थापित करना चाहते हैं।
* _ऑटोस्केल नोड्स_: अधिकांश क्लाउड प्रदाता अस्वस्थ नोड्स को बदलने के लिए [क्लस्टर ऑटोस्केलर](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler#readme)
का समर्थन करते हैं या मांग के अनुसार नोड्स की संख्या को बढ़ाते और घटाते हैं। विभिन्न क्लाउड प्रदाताओं द्वारा इसे कैसे कार्यान्वित किया जाता है, इसके लिए [अक्सर पूछे जाने वाले प्रश्न](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md)
ऑटोस्केलर कैसे काम करता है और [डिप्लॉयमेंट](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler#deployment)
देखें। ऑन-प्रिमाइसेस के लिए, कुछ वर्चुअलाइजेशन प्लेटफॉर्म हैं जिन्हें मांग के आधार पर नए नोड्स को स्पिन करने के लिए स्क्रिप्ट किया जा सकता है।
* _नोड स्वास्थ्य जांच सेट करें_: महत्वपूर्ण कार्यभार के लिए, आप यह सुनिश्चित करना चाहते हैं कि उन नोड्स पर चलने वाले नोड और पॉड स्वस्थ हैं। [नोड समस्या डिटेक्टर](https://kubernetes.io/docs/tasks/debug-application-cluster/monitor-node-health/)
डेमॉन का उपयोग करके, आप सुनिश्चित कर सकते हैं कि आपके नोड स्वस्थ हैं।
उत्पादन उपयोगकर्ता प्रबंधन
--------------------------
उत्पादन में, आप उस मॉडल से आगे बढ़ रहे हैं जहां आप या लोगों का एक छोटा समूह क्लस्टर तक पहुंच रहा है जहां संभावित रूप से दर्जनों या सैकड़ों लोग हो सकते हैं। सीखने के माहौल या प्लेटफ़ॉर्म प्रोटोटाइप में, आप जो कुछ भी करते हैं उसके लिए आपके पास एक ही प्रशासनिक खाता हो सकता है। उत्पादन में, आप विभिन्न नेमस्पेस्सों तक पहुंच के विभिन्न स्तरों वाले अधिक खाते चाहते हैं।
उत्पादन-गुणवत्ता वाले क्लस्टर को लेने का अर्थ है यह तय करना कि आप कैसे हैं अन्य उपयोगकर्ताओं द्वारा चुनिंदा रूप से पहुंच की अनुमति देना चाहते हैं। विशेष रूप से, आपको उन लोगों की पहचान को सत्यापित करने के लिए रणनीतियों का चयन करने की आवश्यकता है जो आपके क्लस्टर (प्रमाणीकरण) तक पहुंचने का प्रयास करते हैं और यह तय करते हैं कि क्या उनके पास वह करने की अनुमति है जो वे पूछ रहे हैं (प्राधिकरण):
* _प्रमाणीकरण_: apiserver क्लाइंट का उपयोग करके उपयोगकर्ताओं को प्रमाणित कर सकता है प्रमाण पत्र, वाहक टोकन, एक प्रमाणीकरण प्रॉक्सी, या HTTP मूल प्रमाणीकरण। आप चुन सकते हैं कि आप किन प्रमाणीकरण विधियों का उपयोग करना चाहते हैं। प्लगइन्स का उपयोग करके, apiserver आपके संगठन की मौजूदा प्रमाणीकरण विधियों, जैसे LDAP या Kerberos का लाभ उठा सकता है। कुबेरनेट्स उपयोगकर्ताओं को प्रमाणित करने के इन विभिन्न तरीकों के विवरण के लिए [प्रमाणीकरण](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)
देखो।
* _प्राधिकरण_: जब आप अपने नियमित उपयोगकर्ताओं को अधिकृत करने के लिए निकलते हैं, तो आप शायद आरबीएसी और एबीएसी प्राधिकरण के बीच चयन करेंगे। उपयोगकर्ता खातों को अधिकृत करने के लिए विभिन्न तरीकों की समीक्षा करने के लिए [प्राधिकरण अवलोकन](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)
देखें (साथ ही आपके क्लस्टर में सेवा खाते तक पहुंच):
* _भूमिका-आधारित अभिगम नियंत्रण_ ([RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)
): प्रमाणित उपयोगकर्ताओं को अनुमतियों के विशिष्ट सेट की अनुमति देकर आप अपने क्लस्टर तक पहुँच प्रदान कर सकते हैं। अनुमतियाँ एक विशिष्ट नेमस्पेस्स (भूमिका) या संपूर्ण क्लस्टर (ClusterRole) के लिए असाइन की जा सकती हैं। फिर रोलबाइंडिंग और क्लस्टररोलबाइंडिंग का उपयोग करके, उन अनुमतियों को विशेष उपयोगकर्ताओं से जोड़ा जा सकता है।
* _विशेषता-आधारित अभिगम नियंत्रण_ ([ABAC](https://kubernetes.io/docs/reference/access-authn-authz/abac/)
): आपको क्लस्टर में संसाधन विशेषताओं के आधार पर नीतियां बनाने देता है और उन विशेषताओं के आधार पर पहुंच की अनुमति देगा या अस्वीकार करेगा। नीति फ़ाइल की प्रत्येक पंक्ति विषय (उपयोगकर्ता या समूह), संसाधन संपत्ति, गैर-संसाधन संपत्ति (/ संस्करण या / एपिस), और केवल पढ़ने के लिए संस्करण गुणों (एपीआई संस्करण और प्रकार) और विशिष्ट गुणों के मानचित्र की पहचान करती है। विवरण के लिए देखें [उदाहरण](https://kubernetes.io/docs/reference/access-authn-authz/abac/#examples)
।
जब कोई आपके उत्पादन कुबेरनेट्स क्लस्टर पर प्रमाणीकरण और प्राधिकरण सेटअप कर रहा हो, तो यहां कुछ बातों पर विचार करना चाहिए:
* _प्राधिकरण मोड सेट करें_: जब कुबेरनेट्स एपीआई सर्वर ([kube-apiserver](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/)
) शुरू होता है, समर्थित प्रमाणीकरण मोड को _\--authorization-mode_ फ़्लैग का उपयोग करके सेट किया जाना चाहिए। उदाहरण के लिए, _kube-adminserver.yaml_ फ़ाइल में वह फ़्लैग (_/etc/kubernetes/manifests_ में) नोड, आरबीएसी पर सेट किया जा सकता है। यह प्रमाणित अनुरोधों के लिए नोड और आरबीएसी प्राधिकरण की अनुमति देगा।
* _उपयोगकर्ता प्रमाणपत्र और रोल बाइंडिंग (RBAC) बनाएं_: यदि आप आरबीएसी प्राधिकरण का उपयोग कर रहे हैं, तो उपयोगकर्ता एक सर्टिफिकेट साइनिंग रिक्वेस्ट (सीएसआर) बना सकते हैं जिस पर क्लस्टर सीए द्वारा हस्ताक्षर किए जा सकते हैं। फिर आप प्रत्येक उपयोगकर्ता के लिए रोल्स और क्लस्टररोल्स को बाध्य कर सकते हैं। विवरण के लिए [प्रमाणपत्र पर हस्ताक्षर करने के अनुरोध](https://kubernetes.io/docs/reference/access-authn-authz/certificate-signing-requests/)
देखें।
* _ऐसी नीतियां बनाएं जो विशेषताओं को जोड़ती हैं (ABAC)_: यदि आप एबीएसी प्राधिकरण का उपयोग कर रहे हैं, तो आप चुनिंदा उपयोगकर्ताओं या समूहों को विशेष संसाधनों (जैसे पॉड), नेमस्पेस, या एपीग्रुप तक पहुंचने के लिए अधिकृत करने के लिए नीतियां बनाने के लिए विशेषताओं के संयोजन असाइन कर सकते हैं। अधिक जानकारी के लिए देखें [उदाहरण](https://kubernetes.io/docs/reference/access-authn-authz/abac/#examples)
।
* _प्रवेश नियंत्रकों पर विचार करें_: एपीआई सर्वर के माध्यम से आने वाले अनुरोधों के लिए प्राधिकरण के अतिरिक्त रूपों में शामिल हैं [वेबहुक टोकन प्रमाणीकरण](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#webhook-token-authentication)
। वेबहुक और अन्य विशेष प्राधिकरण प्रकारों को एपीआई सर्वर में [प्रवेश नियंत्रक](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)
जोड़कर सक्षम करने की आवश्यकता है।
कार्यभार संसाधनों पर सीमा निर्धारित करें
----------------------------------------
उत्पादन कार्यभार की मांग कुबेरनेट्स नियंत्रण विमान के अंदर और बाहर दोनों जगह दबाव पैदा कर सकती है। अपने क्लस्टर के वर्कलोड की जरूरतों के लिए सेट अप करते समय इन मदों पर विचार करें:
* _नेमस्पेस्स की सीमा निर्धारित करें_: मेमोरी और सीपीयू जैसी चीजों पर प्रति नेमस्पेस कोटा सेट करें। विवरण के लिए [मेमोरी, सीपीयू और एपीआई संसाधन प्रबंधित करें](https://kubernetes.io/docs/tasks/administer-cluster/manage-resources/)
देखें। आप इनहेरिट करने की सीमा के लिए [हिरार्चीकैल नेमस्पेस्स](https://kubernetes.io/blog/2020/08/14/introducing-hierarchical-namespaces/)
भी सेट कर सकते हैं।
* _DNS मांग के लिए तैयार करें_: यदि आप वर्कलोड के बड़े पैमाने पर बढ़ने की उम्मीद करते हैं, तो आपकी DNS सेवा भी बड़े पैमाने पर तैयार होनी चाहिए। [क्लस्टर में DNS सेवा को ऑटोस्केल करना](https://kubernetes.io/docs/tasks/administer-cluster/dns-horizontal-autoscaling/)
देखें।
* _अतिरिक्त सेवा खाते बनाएं_: उपयोगकर्ता खाते यह निर्धारित करते हैं कि उपयोगकर्ता क्लस्टर पर क्या कर सकते हैं, जबकि एक सेवा खाता किसी विशेष नेमस्पेस्स के भीतर पॉड एक्सेस को परिभाषित करता है। डिफ़ॉल्ट रूप से, एक पॉड अपने नेमस्पेस्स से डिफ़ॉल्ट सेवा खाता लेता है। नया सेवा खाता बनाने के बारे में जानकारी के लिए [सेवा खातों का प्रबंधन](https://kubernetes.io/docs/reference/access-authn-authz/service-accounts-admin/)
देखें। उदाहरण के लिए, आप शायद यह करना चाहें:
* ऐसे रहस्य जोड़ें जिनका उपयोग पॉड किसी विशेष कंटेनर रजिस्ट्री से इमेज खींचने के लिए कर सकता है। उदाहरण के लिए [पॉड्स के लिए सेवा खाते कॉन्फ़िगर करें](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/)
देखें।
* किसी सेवा खाते में RBAC अनुमतियाँ असाइन करें। विवरण के लिए [सेवा खाता अनुमतियां](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#service-account-permissions)
देखें।
आगे क्या है
-----------
* तय करें कि आप अपना खुद का उत्पादन कुबेरनेट्स बनाना चाहते हैं या उपलब्ध [टर्नकी क्लाउड सॉल्यूशंस](https://kubernetes.io/hi/docs/setup/production-environment/turnkey-solutions/)
से एक प्राप्त करना चाहते हैं या [कुबेरनेट्स पार्टनर्स](https://kubernetes.io/partners/)
।
* यदि आप अपना स्वयं का क्लस्टर बनाना चुनते हैं, तो योजना बनाएं कि आप [प्रमाणपत्र](https://kubernetes.io/docs/setup/best-practices/certificates/)
को कैसे संभालना चाहते हैं और [etcd](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm/)
जैसी सुविधाओं के लिए उच्च उपलब्धता सेट करें। और [एपीआई सर्वर](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/ha-topology/)
।
* [kubeadm](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/)
, [kops](https://kubernetes.io/docs/setup/production-environment/tools/kops/)
या [kubespray](https://kubernetes.io/docs/setup/production-environment/tools/kubespray/)
डिप्लॉयमेंट विधियों में से चुनें।
* अपना निर्धारित करके उपयोगकर्ता प्रबंधन को कॉन्फ़िगर करें [प्रमाणीकरण](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)
और [प्राधिकरण](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)
विधियां।
* सेटअप करके एप्लिकेशन वर्कलोड की तैयारी करें [संसाधन सीमाएं](https://kubernetes.io/docs/tasks/administer-cluster/manage-resources/)
, [DNS ऑटोस्केलिंग](https://kubernetes.io/docs/tasks/administer-cluster/dns-horizontal-autoscaling/)
और [सेवा खाते](https://kubernetes.io/docs/reference/access-authn-authz/service-accounts-admin/)
।
1 - कंटेनर रनटाइम
=================
आपको क्लस्टर में प्रत्येक नोड में एक [कंटेनर रनटाइम](https://kubernetes.io/hi/docs/setup/production-environment/container-runtimes "The container runtime is the software that is responsible for running containers.")
इंस्टॉल करना होगा ताकि पॉड वहां चल सकें। यह पृष्ठ बताता है कि क्या शामिल है और नोड्स की स्थापना के लिए संबंधित कार्यों का वर्णन करता है।
कुबेरनेट्स 1.35 के लिए आवश्यक है कि आप एक रनटाइम का उपयोग करें जो [कंटेनर रनटाइम इंटरफ़ेस](https://kubernetes.io/hi/docs/concepts/overview/components/#container-runtime "क्यूबलेट के साथ एकीकृत करने के लिए कंटेनर रनटाइम के लिए एक API")
(CRI) के अनुरूप है।
अधिक जानकारी के लिए [CRI version support](https://kubernetes.io/hi/docs/setup/production-environment/_print/#cri-versions)
देखें।
यह पृष्ठ Linux पर कुबेरनेट्स के साथ कई सामान्य कंटेनर रनटाइम का उपयोग करने के विवरण सूचीबद्ध करता है:
* [containerd](https://kubernetes.io/hi/docs/setup/production-environment/_print/#containerd)
* [CRI-O](https://kubernetes.io/hi/docs/setup/production-environment/_print/#cri-o)
* [Docker Engine](https://kubernetes.io/hi/docs/setup/production-environment/_print/#docker)
* [Mirantis Container Runtime](https://kubernetes.io/hi/docs/setup/production-environment/_print/#mcr)
#### टिप्पणी:
अन्य ऑपरेटिंग सिस्टम के लिए, अपने प्लेटफ़ॉर्म के अनुसार विशिष्ट प्रलेखन देखें।
Cgroup ड्राइवर
--------------
प्रक्रियाओं के लिए आवंटित संसाधनों को सीमित करने के लिए कंट्रोल ग्रुप का उपयोग किया जाता है।
जब Linux वातावरण के लिए init सिस्टम, [systemd](https://www.freedesktop.org/wiki/Software/systemd/)
को चुना जाता है, तब init प्रक्रिया रुट(root) control group (`cgroup`) उत्पन्न करती है और उपभोग करती है तथा cgroup मैनेजर की तरह काम करता है। Systemd और cgroups एकीकृत हैं और प्रत्येक systemd यूनिट को एक cgroup आवंटित होता है। अपने कन्टैनर रनटाइम और kubelet को `cgroupfs` प्रयोग करने के लिए कॉन्फ़िगर करना संभव है। systemd के साथ `cgroupfs` प्रयोग करने के कारण दो अलग cgroup मैनेजर होंगे।
एक एकल cgroup प्रबंधक इस दृष्टिकोण को सरल बनाता है कि कौन से संसाधन आवंटित किए जा रहे हैं और डिफ़ॉल्ट रूप से उपलब्ध और उपयोग में आने वाले संसाधनों के बारे में अधिक सुसंगत दृश्य होगा। जब एक सिस्टम पर दो cgroup मैनेजर होते हैं, तो आपको उन रिसोर्सेज के दो व्यू मिलते हैं। क्षेत्र में, लोगों ने ऐसे मामलों की सूचना दी है जहां नोड्स जो kubelet और डॉकर के लिए `cgroupfs` का उपयोग करने के लिए कॉन्फ़िगर किए गए हैं, लेकिन बाकी प्रक्रियाओं के लिए `systemd` संसाधन दबाव के कारण अस्थिर हो जाते हैं।
सेटिंग्स को इस तरह बदलना कि आपका कंटेनर रनटाइम और kubelet `systemd` का उपयोग करें क्योंकि cgroup ड्राइवर सिस्टम को स्थिर करता है। डॉकर के लिए इसे कॉन्फ़िगर करने के लिए, `native.cgroupdriver=systemd` सेट करें।
#### सावधान:
क्लस्टर में शामिल होने वाले नोड के cgroup ड्राइवर को बदलना एक संवेदनशील ऑपरेशन है। यदि kubelet ने एक सीग्रुप ड्राइवर के सिमेंटिक्स (semantics) का उपयोग करके पॉड्स बनाए हैं, तो कंटेनर रनटाइम को दूसरे सीग्रुप ड्राइवर में बदलने से मौजूदा पॉड्स के पॉड सैंडबॉक्स को फिर से बनाते समय त्रुटियां हो सकती हैं। kubelet को पुनरारंभ करने से ऐसी त्रुटियों का समाधान नहीं हो सकता है।
यदि आपके पास स्वचालन है जो इसे व्यवहार्य बनाता है, तो अद्यतन किए गए कॉन्फ़िगरेशन का उपयोग करके नोड को दूसरे के साथ बदलें, या स्वचालन का उपयोग करके इसे पुनर्स्थापित करें।
Cgroup v2
---------
Cgroup v2, cgroup Linux API का अगला संस्करण है। Cgroup v1 से अलग, प्रत्येक कंट्रोलर के लिए एक अलग अनुक्रम के बजाय एक पदानुक्रम है।
नया संस्करण cgroup v1 पर कई सुधार प्रदान करता है, इनमें से कुछ सुधार हैं:
* API का उपयोग करने का स्पष्ट और आसान तरीका
* कंटेनरों के लिए सुरक्षित उप-वृक्ष प्रतिनिधिमंडल
* प्रेशर स्टॉल की जानकारी जैसी नई सुविधाएँ
भले ही कर्नेल हाइब्रिड कॉन्फ़िगरेशन का समर्थन करता हो, जहां कुछ नियंत्रक cgroup v1 द्वारा प्रबंधित किए जाते हैं और कुछ अन्य cgroup v2 द्वारा, Kubernetes सभी नियंत्रकों को प्रबंधित करने के लिए केवल उसी cgroup संस्करण का समर्थन करता है।
यदि सिस्टमड (Systemd) डिफ़ॉल्ट रूप से cgroup v2 का उपयोग नहीं करता है, तो आप कर्नेल कमांड लाइन में `systemd.unified_cgroup_hierarchy=1` जोड़कर सिस्टम को इसका उपयोग करने के लिए कॉन्फ़िगर कर सकते हैं।
# यह उदाहरण एक Linux OS के लिए है जो DNF पैकेज मैनेजर का उपयोग करता है
# आपका सिस्टम कमांड लाइन सेट करने के लिए एक अलग विधि का उपयोग कर सकता है
# लिनक्स कर्नेल का उपयोग करता है।
sudo dnf install -y grubby && \
sudo grubby \
--update-kernel=ALL \
--args="systemd.unified_cgroup_hierarchy=1"
यदि आप कर्नेल के लिए कमांड लाइन बदलते हैं, तो आपको अपने से पहले नोड को रिबूट करना होगा परिवर्तन प्रभावी होता है।
Cgroup v2 में स्विच करते समय उपयोगकर्ता अनुभव में कोई उल्लेखनीय अंतर नहीं होना चाहिए, जब तक कि उपयोगकर्ता सीग्रुप फाइल सिस्टम को सीधे नोड पर या कंटेनरों के भीतर से एक्सेस कर रहे हैं।
इसका उपयोग करने के लिए, Cgroup v2 को CRI रनटाइम द्वारा भी सपोर्टेड (supported) होना चाहिए।
### Kubeadm प्रबंधित क्लस्टर में `systemd` ड्राइवर में माइग्रेट करना
यदि आप मौजूदा kubeadm प्रबंधित क्लस्टर में `systemd` cgroup ड्राइवर में माइग्रेट करना चाहते हैं, तो [माइग्रेशन गाइड](https://kubernetes.io/docs/tasks/administer-cluster/kubeadm/configure-cgroup-driver/)
का पालन करें।
CRI संस्करण समर्थन
------------------
आपके कंटेनर रनटाइम को कंटेनर रनटाइम इंटरफ़ेस के कम से कम v1alpha2 का समर्थन करना चाहिए।
कुबेरनेट्स 1.35 डिफ़ॉल्ट रूप से CRI API के v1 का उपयोग करता है। यदि कंटेनर रनटाइम v1 API का समर्थन नहीं करता है, तो क्यूबलेट वापस आ जाता है इसके बजाय (बहिष्कृत) v1alpha2 API का उपयोग करना।
कंटेनर रनटाइम
-------------
**टिप्पणी:** यह खंड अन्य पक्ष परियोजनाओं से जुड़ा है जो कुबेरनेट्स द्वारा आवश्यक कार्यक्षमता प्रदान करते हैं। कुबेरनेट्स परियोजना के लेखक इन परियोजनाओं के लिए जिम्मेदार नहीं हैं। यह पृष्ठ [CNCF वेबसाइट दिशानिर्देश](https://github.com/cncf/foundation/blob/master/website-guidelines.md)
का अनुसरण करते हुए परियोजनाओं को वर्णानुक्रम में सूचीबद्ध करता है। इस सूची में कोई नई परियोजना जोड़ने से पहले यह [विषय मार्गदर्शक](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
पृष्ट पढ़के ही परिवर्तन करें।
### कंटेनरडी
यह खंड कंटेनरडी को CRI रनटाइम के रूप में उपयोग करने के लिए आवश्यक कदम है।
अपने सिस्टम पर containerd इंस्टॉल करने के लिए निम्नलिखित कमांड का उपयोग करें:
पूर्वापेक्षाएँ इंस्टॉल और कॉन्फ़िगर करें:
cat < 443/TCP 17d
The default Service, in this case, uses the ClusterIP 10.96.0.1, that has the corresponding IPAddress object.
kubectl get ipaddress 10.96.0.1
NAME PARENTREF
10.96.0.1 services/default/kubernetes
The ServiceCIDRs are protected with [finalizers](https://kubernetes.io/docs/concepts/overview/working-with-objects/finalizers/ "A namespaced key that tells Kubernetes to wait until specific conditions are met before it fully deletes an object marked for deletion.")
, to avoid leaving Service ClusterIPs orphans; the finalizer is only removed if there is another subnet that contains the existing IPAddresses or there are no IPAddresses belonging to the subnet.
Extend the number of available IPs for Services
-----------------------------------------------
There are cases that users will need to increase the number addresses available to Services, previously, increasing the Service range was a disruptive operation that could also cause data loss. With this new feature users only need to add a new ServiceCIDR to increase the number of available addresses.
### Adding a new ServiceCIDR
On a cluster with a 10.96.0.0/28 range for Services, there is only 2^(32-28) - 2 = 14 IP addresses available. The `kubernetes.default` Service is always created; for this example, that leaves you with only 13 possible Services.
for i in $(seq 1 13); do kubectl create service clusterip "test-$i" --tcp 80 -o json | jq -r .spec.clusterIP; done
10.96.0.11
10.96.0.5
10.96.0.12
10.96.0.13
10.96.0.14
10.96.0.2
10.96.0.3
10.96.0.4
10.96.0.6
10.96.0.7
10.96.0.8
10.96.0.9
error: failed to create ClusterIP service: Internal error occurred: failed to allocate a serviceIP: range is full
You can increase the number of IP addresses available for Services, by creating a new ServiceCIDR that extends or adds new IP address ranges.
cat 80/TCP 5s
Validate that the Service gets cluster IPs from the IPv4 and IPv6 address blocks using `kubectl describe`. You may then validate access to the service via the IPs and ports.
kubectl describe svc -l app.kubernetes.io/name=MyApp
Name: my-service
Namespace: default
Labels: app.kubernetes.io/name=MyApp
Annotations:
Selector: app.kubernetes.io/name=MyApp
Type: ClusterIP
IP Family Policy: PreferDualStack
IP Families: IPv4,IPv6
IP: 10.0.216.242
IPs: 10.0.216.242,2001:db8:fd00::af55
Port: 80/TCP
TargetPort: 9376/TCP
Endpoints:
Session Affinity: None
Events:
### Create a dual-stack load balanced Service
If the cloud provider supports the provisioning of IPv6 enabled external load balancers, create the following Service with `PreferDualStack` in `.spec.ipFamilyPolicy`, `IPv6` as the first element of the `.spec.ipFamilies` array and the `type` field set to `LoadBalancer`.
[`service/networking/dual-stack-prefer-ipv6-lb-svc.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/en/examples/service/networking/dual-stack-prefer-ipv6-lb-svc.yaml)

apiVersion: v1
kind: Service
metadata:
name: my-service
labels:
app.kubernetes.io/name: MyApp
spec:
ipFamilyPolicy: PreferDualStack
ipFamilies:
- IPv6
type: LoadBalancer
selector:
app.kubernetes.io/name: MyApp
ports:
- protocol: TCP
port: 80
Check the Service:
kubectl get svc -l app.kubernetes.io/name=MyApp
Validate that the Service receives a `CLUSTER-IP` address from the IPv6 address block along with an `EXTERNAL-IP`. You may then validate access to the service via the IP and port.
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-service LoadBalancer 2001:db8:fd00::7ebc 2603:1030:805::5 80:30790/TCP 35s
---
# Concetti | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/concepts/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/concepts/)
.
Concetti
========
* 1: [Overview](https://kubernetes.io/it/docs/concepts/_print/#pg-0554ac387412eaf4e6e89b2f847dacde)
* 1.1: [Cos'è Kubernetes?](https://kubernetes.io/it/docs/concepts/_print/#pg-45bdca6129cf540121623e903c18ba46)
* 1.2: [I componenti di Kubernetes](https://kubernetes.io/it/docs/concepts/_print/#pg-13b0f1dbe89228e3d76d2ac231e245f1)
* 1.3: [Le API di Kubernetes](https://kubernetes.io/it/docs/concepts/_print/#pg-0c745f42e623d2b70a53bc0e6db73d95)
* 2: [Architettura di Kubernetes](https://kubernetes.io/it/docs/concepts/_print/#pg-2bf36ccd6b3dbeafecf87c39761b07c7)
* 2.1: [Comunicazione Control Plane - Nodo](https://kubernetes.io/it/docs/concepts/_print/#pg-c0251def6da29b30afebfb04549f1703)
* 2.2: [Concetti alla base del Cloud Controller Manager](https://kubernetes.io/it/docs/concepts/_print/#pg-bc804b02614d67025b4c788f1ca87fbc)
* 2.3: [Controller](https://kubernetes.io/it/docs/concepts/_print/#pg-ca8819042a505291540e831283da66df)
* 3: [Containers](https://kubernetes.io/it/docs/concepts/_print/#pg-a5f7383c83ab9eb9cd0e3c4c020b3ae6)
* 3.1: [Immagini](https://kubernetes.io/it/docs/concepts/_print/#pg-16042b4652ad19e565c7263824029a43)
* 3.2: [Container Environment](https://kubernetes.io/it/docs/concepts/_print/#pg-643212488f778acf04bebed65ba34441)
* 3.3: [Container Lifecycle Hooks](https://kubernetes.io/it/docs/concepts/_print/#pg-e6941d969d81540208a3e78bc56f43bc)
* 4: [Configurazione](https://kubernetes.io/it/docs/concepts/_print/#pg-275bea454e1cf4c5adeca4058b5af988)
* 4.1: [ConfigMaps](https://kubernetes.io/it/docs/concepts/_print/#pg-6b5ccadd699df0904e8e9917c5450c4b)
* 5: [Amministrazione del Cluster](https://kubernetes.io/it/docs/concepts/_print/#pg-285a3785fd3d20f437c28d87ca4dadca)
* 5.1: [Proxy in Kubernetes](https://kubernetes.io/it/docs/concepts/_print/#pg-08e94e6a480e0d6b2de72d84a1b97617)
* 6: [Esempio di modello di concetto](https://kubernetes.io/it/docs/concepts/_print/#pg-4c31edff4063c7b31c556b3eb1405c65)
La sezione Concetti ti aiuta a conoscere le parti del sistema Kubernetes e le astrazioni utilizzate da Kubernetes per rappresentare il tuo cluster e ti aiuta ad ottenere una comprensione più profonda di come funziona Kubernetes.
Overview
--------
Per lavorare con Kubernetes, usi _gli oggetti API Kubernetes_ per descrivere lo _stato desiderato del tuo cluster_: quali applicazioni o altri carichi di lavoro vuoi eseguire, quali immagini del contenitore usano, numero di repliche, quali risorse di rete e disco vuoi rendere disponibile e altro ancora. Puoi impostare lo stato desiderato creando oggetti usando l'API di Kubernetes, in genere tramite l'interfaccia della riga di comando, `kubectl`. Puoi anche utilizzare direttamente l'API di Kubernetes per interagire con il cluster e impostare o modificare lo stato desiderato.
Una volta impostato lo stato desiderato, il _Kubernetes Control Plane_ funziona per fare in modo che lo stato corrente del cluster corrisponda allo stato desiderato. Per fare ciò, Kubernetes esegue automaticamente una serie di attività, come l'avvio o il riavvio dei contenitori, il ridimensionamento del numero di repliche di una determinata applicazione e altro ancora. Il piano di controllo di Kubernetes è costituito da una raccolta di processi in esecuzione sul cluster:
* Il **Kubernetes Master** è una raccolta di tre processi che vengono eseguiti su un singolo nodo nel cluster, che è designato come nodo principale. Questi processi sono: [kube-apiserver](https://kubernetes.io/docs/admin/kube-apiserver/)
, [kube-controller-manager](https://kubernetes.io/docs/admin/kube-controller-manager/)
e [kube-scheduler](https://kubernetes.io/docs/admin/kube-scheduler/)
.
* Ogni singolo nodo non principale nel cluster esegue due processi: \* **[kubelet](https://kubernetes.io/docs/admin/kubelet/)
**, che comunica con il master di Kubernetes. \* **[kube-proxy](https://kubernetes.io/docs/admin/kube-proxy/)
**, un proxy di rete che riflette i servizi di rete di Kubernetes su ciascun nodo.
Kubernetes Objects
------------------
kubernetes contiene una serie di astrazioni che rappresentano lo stato del tuo sistema: applicazioni e carichi di lavoro distribuiti in container, le loro risorse di rete e disco associate e altre informazioni su ciò che sta facendo il tuo cluster. Queste astrazioni sono rappresentate da oggetti nell'API di Kubernetes; guarda la [Panoramica degli oggetti di Kubernetes](https://kubernetes.io/docs/concepts/abstractions/overview/)
per maggiori dettagli.
Gli oggetti di base di Kubernetes includono:
* [Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod-overview/)
* [Service](https://kubernetes.io/docs/concepts/services-networking/service/)
* [Volume](https://kubernetes.io/docs/concepts/storage/volumes/)
* [Namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/)
209/5000 Inoltre, Kubernetes contiene una serie di astrazioni di livello superiore denominate Controllori. I controller si basano sugli oggetti di base e forniscono funzionalità aggiuntive e funzionalità di convenienza. Loro includono:
* [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)
* [Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
* [StatefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)
* [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)
* [Job](https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/)
Kubernetes Control Plane
------------------------
Le varie parti del Piano di controllo di Kubernetes, come i master Kubernetes e i processi di Kubelet, regolano il modo in cui Kubernetes comunica con il cluster. Il Piano di controllo mantiene un registro di tutti gli oggetti Kubernetes nel sistema e esegue cicli di controllo continui per gestire lo stato di tali oggetti. In qualsiasi momento, i loop di controllo di Control Plane risponderanno ai cambiamenti nel cluster e lavoreranno per fare in modo che lo stato effettivo di tutti gli oggetti nel sistema corrisponda allo stato desiderato che hai fornito.
Ad esempio, quando si utilizza l'API di Kubernetes per creare un oggetto di distribuzione, si fornisce un nuovo stato desiderato per il sistema. Il piano di controllo di Kubernetes registra la creazione dell'oggetto e svolge le tue istruzioni avviando le applicazioni richieste e pianificandole sui nodi del cluster, in modo che lo stato effettivo del cluster corrisponda allo stato desiderato.
### Kubernetes Master
Il master Kubernetes è responsabile della gestione dello stato desiderato per il tuo cluster. Quando interagisci con Kubernetes, ad esempio utilizzando l'interfaccia della riga di comando `kubectl`, stai comunicando con il master di Kubernetes del cluster.
> Il "master" si riferisce a una raccolta di processi che gestiscono lo stato del cluster. In genere questi processi vengono eseguiti tutti su un singolo nodo nel cluster e questo nodo viene anche definito master. Il master può anche essere replicato per disponibilità e ridondanza.
### Kubernetes Nodes
I nodi di un cluster sono le macchine (VM, server fisici, ecc.) che eseguono i flussi di lavoro delle applicazioni e del cloud. Il master Kubernetes controlla ciascun nodo; raramente interagirai direttamente con i nodi.
#### Object Metadata
* [Annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/)
Voci correlate
--------------
Se vuoi scrivere una pagina concettuale, vedi [Uso dei modelli di pagina](https://kubernetes.io/docs/home/contribute/page-templates/)
per informazioni sul tipo di pagina di concetto e il modello di concetto.
1 - Overview
============
1.1 - Cos'è Kubernetes?
=======================
Kubernetes è una piattaforma portatile, estensibile e open-source per la gestione di carichi di lavoro e servizi containerizzati, in grado di facilitare sia la configurazione dichiarativa che l'automazione. La piattaforma vanta un grande ecosistema in rapida crescita. Servizi, supporto e strumenti sono ampiamente disponibili nel mondo Kubernetes .
Questa pagina è una panoramica generale su Kubernetes.
Kubernetes è una piattaforma portatile, estensibile e open-source per la gestione di carichi di lavoro e servizi containerizzati, in grado di facilitare sia la configurazione dichiarativa che l'automazione. La piattaforma vanta un grande ecosistema in rapida crescita. Servizi, supporto e strumenti sono ampiamente disponibili nel mondo Kubernetes .
Il nome Kubernetes deriva dal greco, significa timoniere o pilota. Google ha reso open-source il progetto Kubernetes nel 2014. Kubernetes unisce [oltre quindici anni di esperienza di Google](https://kubernetes.io/blog/2015/04/borg-predecessor-to-kubernetes/)
nella gestione di carichi di lavoro di produzione su scala mondiale con le migliori idee e pratiche della comunità.
Facciamo un piccolo salto indietro
----------------------------------
Diamo un'occhiata alla ragione per cui Kubernetes è così utile facendo un piccolo salto indietro nel tempo.

**L'era del deployment tradizionale:** All'inizio, le organizzazioni eseguivano applicazioni su server fisici. Non c'era modo di definire i limiti delle risorse per le applicazioni in un server fisico e questo ha causato non pochi problemi di allocazione delle risorse. Ad esempio, se più applicazioni vengono eseguite sullo stesso server fisico, si possono verificare casi in cui un'applicazione assorbe la maggior parte delle risorse e, di conseguenza, le altre applicazioni non hanno le prestazioni attese. Una soluzione per questo sarebbe di eseguire ogni applicazione su un server fisico diverso. Ma questa non è una soluzione ideale, dal momento che le risorse vengono sottoutilizzate, inoltre, questa pratica risulta essere costosa per le organizzazioni, le quali devono mantenere numerosi server fisici.
**L'era del deployment virtualizzato:** Come soluzione venne introdotta la virtualizzazione. Essa consente di eseguire più macchine virtuali (VM) su una singola CPU fisica. La virtualizzazione consente di isolare le applicazioni in più macchine virtuali e fornisce un livello di sicurezza superiore, dal momento che le informazioni di un'applicazione non sono liberamente accessibili da un'altra applicazione.
La virtualizzazione consente un migliore utilizzo delle risorse riducendo i costi per l'hardware, permette una migliore scalabilità, dato che un'applicazione può essere aggiunta o aggiornata facilmente, e ha molti altri vantaggi.
Ogni VM è una macchina completa che esegue tutti i componenti, compreso il proprio sistema operativo, sopra all'hardware virtualizzato.
**L'era del deployment in container:** I container sono simili alle macchine virtuali, ma presentano un modello di isolamento più leggero, condividendo il sistema operativo (OS) tra le applicazioni. Pertanto, i container sono considerati più leggeri. Analogamente a una macchina virtuale, un container dispone di una segregazione di filesystem, CPU, memoria, PID e altro ancora. Poiché sono disaccoppiati dall'infrastruttura sottostante, risultano portabili tra differenti cloud e diverse distribuzioni.
I container sono diventati popolari dal momento che offrono molteplici vantaggi, ad esempio:
* Creazione e distribuzione di applicazioni in modalità Agile: maggiore facilità ed efficienza nella creazione di immagini container rispetto all'uso di immagini VM.
* Adozione di pratiche per lo sviluppo/test/rilascio continuativo: consente la frequente creazione e la distribuzione di container image affidabili, dando la possibilità di fare rollback rapidi e semplici (grazie all'immutabilità dell'immagine stessa).
* Separazione delle fasi di Dev e Ops: le container image vengono prodotte al momento della compilazione dell'applicativo piuttosto che nel momento del rilascio, permettendo così di disaccoppiare le applicazioni dall'infrastruttura sottostante.
* L'osservabilità non riguarda solo le informazioni e le metriche del sistema operativo, ma anche lo stato di salute e altri segnali dalle applicazioni.
* Coerenza di ambiente tra sviluppo, test e produzione: i container funzionano allo stesso modo su un computer portatile come nel cloud.
* Portabilità tra cloud e sistemi operativi differenti: lo stesso container funziona su Ubuntu, RHEL, CoreOS, on-premise, nei più grandi cloud pubblici e da qualsiasi altra parte.
* Gestione incentrata sulle applicazioni: Aumenta il livello di astrazione dall'esecuzione di un sistema operativo su hardware virtualizzato all'esecuzione di un'applicazione su un sistema operativo utilizzando risorse logiche.
* Microservizi liberamente combinabili, distribuiti, ad alta scalabilità: le applicazioni sono suddivise in pezzi più piccoli e indipendenti che possono essere distribuite e gestite dinamicamente - niente stack monolitici che girano su una singola grande macchina.
* Isolamento delle risorse: le prestazioni delle applicazioni sono prevedibili.
* Utilizzo delle risorse: alta efficienza e densità.
Perché necessito di Kubernetes e cosa posso farci
-------------------------------------------------
I container sono un buon modo per distribuire ed eseguire le tue applicazioni. In un ambiente di produzione, è necessario gestire i container che eseguono le applicazioni e garantire che non si verifichino interruzioni dei servizi. Per esempio, se un container si interrompe, è necessario avviare un nuovo container. Non sarebbe più facile se questo comportamento fosse gestito direttamente da un sistema?
È proprio qui che Kubernetes viene in soccorso! Kubernetes ti fornisce un framework per far funzionare i sistemi distribuiti in modo resiliente. Kubernetes si occupa della scalabilità, failover, distribuzione delle tue applicazioni. Per esempio, Kubernetes può facilmente gestire i rilasci con modalità Canary deployment.
Kubernetes ti fornisce:
* **Scoperta dei servizi e bilanciamento del carico** Kubernetes può esporre un container usando un nome DNS o il suo indirizzo IP. Se il traffico verso un container è alto, Kubernetes è in grado di distribuire il traffico su più container in modo che il servizio rimanga stabile.
* **Orchestrazione dello storage** Kubernetes ti permette di montare automaticamente un sistema di archiviazione di vostra scelta, come per esempio storage locale, dischi forniti da cloud pubblici, e altro ancora.
* **Rollout e rollback automatizzati** Puoi utilizzare Kubernetes per descrivere lo stato desiderato per i propri container, e Kubernetes si occuperà di cambiare lo stato attuale per raggiungere quello desiderato ad una velocità controllata. Per esempio, puoi automatizzare Kubernetes per creare nuovi container per il tuo servizio, rimuovere i container esistenti e adattare le loro risorse a quelle richieste dal nuovo container.
* **Ottimizzazione dei carichi** Fornisci a Kubernetes un cluster di nodi per eseguire i container. Puoi istruire Kubernetes su quanta CPU e memoria (RAM) ha bisogno ogni singolo container. Kubernetes allocherà i container sui nodi per massimizzare l'uso delle risorse a disposizione.
* **Self-healing** Kubernetes riavvia i container che si bloccano, sostituisce container, termina i container che non rispondono agli health checks, e evita di far arrivare traffico ai container che non sono ancora pronti per rispondere correttamente.
* **Gestione di informazioni sensibili e della configurazione** Kubernetes consente di memorizzare e gestire informazioni sensibili, come le password, i token OAuth e le chiavi SSH. Puoi distribuire e aggiornare le informazioni sensibili e la configurazione dell'applicazione senza dover ricostruire le immagini dei container e senza svelare le informazioni sensibili nella configurazione del tuo sistema.
Cosa non è Kubernetes
---------------------
Kubernetes non è un sistema PaaS (Platform as a Service) tradizionale e completo. Dal momento che Kubernetes opera a livello di container piuttosto che che a livello hardware, esso fornisce alcune caratteristiche generalmente disponibili nelle offerte PaaS, come la distribuzione, il ridimensionamento, il bilanciamento del carico, la registrazione e il monitoraggio. Tuttavia, Kubernetes non è monolitico, e queste soluzioni predefinite sono opzionali ed estensibili. Kubernetes fornisce gli elementi base per la costruzione di piattaforme di sviluppo, ma conserva le scelte dell'utente e la flessibilità dove è importante.
Kubernetes:
* Non limita i tipi di applicazioni supportate. Kubernetes mira a supportare una grande varietà di carichi di lavoro, compresi i carichi di lavoro stateless, stateful e elaborazione di dati. Se un'applicazione può essere eseguita in un container, dovrebbe funzionare alla grande anche su Kubernetes.
* Non compila il codice sorgente e non crea i container. I flussi di Continuous Integration, Delivery, and Deployment (CI/CD) sono determinati dalla cultura e dalle preferenze dell'organizzazione e dai requisiti tecnici.
* Non fornisce servizi a livello applicativo, come middleware (per esempio, bus di messaggi), framework di elaborazione dati (per esempio, Spark), database (per esempio, mysql), cache, né sistemi di storage distribuito (per esempio, Ceph) come servizi integrati. Tali componenti possono essere eseguiti su Kubernetes, e/o possono essere richiamati da applicazioni che girano su Kubernetes attraverso meccanismi come l'[Open Service Broker](https://openservicebrokerapi.org/)
.
* Non impone soluzioni di logging, monitoraggio o di gestione degli alert. Fornisce alcune integrazioni come dimostrazione, e meccanismi per raccogliere ed esportare le metriche.
* Non fornisce né rende obbligatorio un linguaggio/sistema di configurazione (per esempio, Jsonnet). Fornisce un'API dichiarativa che può essere richiamata da qualsiasi sistema.
* Non fornisce né adotta alcun sistema di gestione completa della macchina, configurazione, manutenzione, gestione o sistemi di self healing.
* Inoltre, Kubernetes non è un semplice sistema di orchestrazione. Infatti, questo sistema elimina la necessità di orchestrazione. La definizione tecnica di orchestrazione è l'esecuzione di un flusso di lavoro definito: prima si fa A, poi B, poi C. Al contrario, Kubernetes è composto da un insieme di processi di controllo indipendenti e componibili che guidano costantemente lo stato attuale verso lo stato desiderato. Non dovrebbe importare come si passa dalla A alla C. Anche il controllo centralizzato non è richiesto. Questo si traduce in un sistema più facile da usare, più potente, robusto, resiliente ed estensibile.
Voci correlate
--------------
* Dai un'occhiata alla pagina [i componenti di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/components/)
* Sai già [Come Iniziare](https://kubernetes.io/docs/setup/)
?
1.2 - I componenti di Kubernetes
================================
Un cluster di Kubernetes è costituito da un insieme di componenti che sono, come minimo, un Control Plane e uno o più sistemi di elaborazione, detti nodi.
Facendo il deployment di Kubernetes, ottieni un cluster.
Un cluster Kubernetes è un'insieme di macchine, chiamate nodi, che eseguono container gestiti da Kubernetes. Un cluster ha almeno un Worker Node.
Il/I Worker Node ospitano i Pod che eseguono i workload dell'utente. Il/I Control Plane Node gestiscono i Worker Node e tutto quanto accade all'interno del cluster. Per garantire la high-availability e la possibilità di failover del cluster, vengono utilizzati più Control Plane Node.
Questo documento descrive i diversi componenti che sono necessari per avere un cluster Kubernetes completo e funzionante.
Questo è un diagramma di un cluster Kubernetes con tutti i componenti e le loro relazioni.

Componenti della Control Plane
------------------------------
I componenti del Control Plane sono responsabili di tutte le decisioni globali sul cluster (ad esempio, lo scheduling) oltre che a rilevare e rispondere agli eventi del cluster (ad esempio, l'avvio di un nuovo [pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
quando il valore `replicas` di un deployment non è soddisfatto).
I componenti della Control Plane possono essere eseguiti su qualsiasi nodo del cluster stesso. Solitamente, per semplicità, gli script di installazione tendono a eseguire tutti i componenti della Control Plane sulla stessa macchina, separando la Control Plane dai workload dell'utente. Vedi [creare un cluster in High-Availability](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/)
per un esempio di un'installazione multi-master.
### kube-apiserver
L'API server è un componente di Kubernetes [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
che espone le Kubernetes API. L'API server è il front end del control plane di Kubernetes.
La principale implementazione di un server Kubernetes API è [kube-apiserver](https://kubernetes.io/docs/reference/generated/kube-apiserver/)
. kube-apiserver è progettato per scalare orizzontalmente, cioè scala aumentando il numero di istanze. Puoi eseguire multiple istanze di kube-apiserver e bilanciare il traffico tra queste istanze.
### etcd
È un database key-value ridondato, che è usato da Kubernetes per salvare tutte le informazioni del cluster.
Se il tuo cluster utilizza etcd per salvare le informazioni, assicurati di avere una strategia di [backup](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/#backing-up-an-etcd-cluster)
per questi dati.
Puoi trovare informazioni dettagliate su etcd sulla [documentazione](https://etcd.io/docs/)
ufficiale.
### kube-scheduler
Componente della Control Plane che controlla i pod appena creati che non hanno un nodo assegnato, e dopo averlo identificato glielo assegna.
I fattori presi in considerazioni nell'individuare un nodo a cui assegnare l'esecuzione di un Pod includono la richiesta di risorse del Pod stesso e degli altri workload presenti nel sistema, i vincoli delle hardware/software/policy, le indicazioni di affinity e di anti-affinity, requisiti relativi alla disponibilità di dati/Volumes, le interferenze tra diversi workload e le scadenze.
### kube-controller-manager
Componente della Control Plane che gestisce [controllers](https://kubernetes.io/it/docs/concepts/architecture/controller/ "Un software che implementa un circuito di controllo che osserva lo stato condiviso del cluster attraverso l'API server e apporta le modifiche necessarie per portate lo stato corrente verso lo stato desiderato.")
.
Da un punto di vista logico, ogni [controller](https://kubernetes.io/it/docs/concepts/architecture/controller/ "Un software che implementa un circuito di controllo che osserva lo stato condiviso del cluster attraverso l'API server e apporta le modifiche necessarie per portate lo stato corrente verso lo stato desiderato.")
è un processo separato, ma per ridurre la complessità, tutti i principali controller di Kubernetes vengono raggruppati in un unico container ed eseguiti in un singolo processo.
Alcuni esempi di controller gestiti dal kube-controller-manager sono:
* Node Controller: Responsabile del monitoraggio dei nodi del cluster, e.g. della gestione delle azioni da eseguire quando un nodo diventa non disponibile.
* Replication Controller: Responsabile per il mantenimento del corretto numero di Pod per ogni ReplicaSet presente nel sistema
* Endpoints Controller: Popola gli oggetti Endpoints (cioè, mette in relazioni i Pods con i Services).
* Service Account & Token Controllers: Creano gli account di default e i token di accesso alle API per i nuovi namespaces.
### cloud-controller-manager
Un componente della [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
di Kubernetes che aggiunge logiche di controllo specifiche per il cloud. Il cloud-controller-manager ti permette di collegare il tuo cluster con le API del cloud provider e separa le componenti che interagiscono con la piattaforma cloud dai componenti che interagiscono solamente col cluster.
Il cloud-controller-manager esegue dei controller specifici del tuo cloud provider. Se hai una installazione Kubernetes on premises, o un ambiente di laboratorio nel tuo PC, il cluster non ha un cloud-controller-manager.
Come nel kube-controller-manager, il cloud-controller-manager combina diversi control loop logicamente indipendenti in un singolo binario che puoi eseguire come un singolo processo. Tu puoi scalare orizzontalmente (eseguire più di una copia) per migliorare la responsività o per migliorare la tolleranza ai fallimenti.
I seguenti controller hanno dipendenze verso implementazioni di specifici cloud provider:
* Node Controller: Per controllare se sul cloud provider i nodi che hanno smesso di rispondere sono stati cancellati
* Route Controller: Per configurare le network route nella sottostante infrastruttura cloud
* Service Controller: Per creare, aggiornare ed eliminare i load balancer del cloud provider
Componenti dei Nodi
-------------------
I componenti del nodo vengono eseguiti su ogni nodo, mantenendo i pod in esecuzione e fornendo l'ambiente di runtime Kubernetes.
### kubelet
Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.
La kubelet riceve un set di PodSpecs che vengono forniti attraverso vari meccanismi, e si assicura che i container descritti in questi PodSpecs funzionino correttamente e siano sani. La kubelet non gestisce i container che non sono stati creati da Kubernetes.
### kube-proxy
[kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/)
è un proxy eseguito su ogni nodo del cluster, responsabile della gestione dei Kubernetes [Service](https://kubernetes.io/it/docs/concepts/services-networking/service/ "A way to expose an application running on a set of Pods as a network service.")
.
I kube-proxy mantengono le regole di networking sui nodi. Queste regole permettono la comunicazione verso gli altri nodi del cluster o l'esterno.
Il kube-proxy usa le librerie del sistema operativo quando possible; in caso contrario il kube-proxy gestisce il traffico direttamente.
### Container Runtime
Il container runtime è il software che è responsabile per l'esecuzione dei container.
Kubernetes supporta diversi container runtimes: [Docker](http://www.docker.com/)
, [containerd](https://containerd.io/)
, [cri-o](https://cri-o.io/)
, [rktlet](https://github.com/kubernetes-incubator/rktlet)
e tutte le implementazioni di [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Addons
------
Gli Addons usano le risorse Kubernetes ([DaemonSet](https://kubernetes.io/it/docs/concepts/workloads/controllers/daemonset "Assicura che una copia di un Pod è attiva su tutti nodi di un cluster.")
, [Deployment](https://kubernetes.io/it/docs/concepts/workloads/controllers/deployment/ "Gestisce una applicazione replicata nel tuo cluster.")
, etc) per implementare funzionalità di cluster. Dal momento che gli addons forniscono funzionalità a livello di cluster, le risorse che necessitano di un namespace, vengono collocate nel namespace `kube-system`.
Alcuni addons sono descritti di seguito; mentre per una più estesa lista di addons, per favore vedere [Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
.
### DNS
Mentre gli altri addons non sono strettamente richiesti, tutti i cluster Kubernetes dovrebbero essere muniti di un [DNS del cluster](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)
, dal momento che molte applicazioni lo necessitano.
Il DNS del cluster è un server DNS aggiuntivo rispetto ad altri server DNS presenti nella rete, e si occupa specificatamente dei record DNS per i servizi Kubernetes.
I container eseguiti da Kubernetes automaticamente usano questo server per la risoluzione DNS.
### Interfaccia web (Dashboard)
La [Dashboard](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)
è una interfaccia web per i cluster Kubernetes. Permette agli utenti di gestire e fare troubleshooting delle applicazioni che girano nel cluster, e del cluster stesso.
### Monitoraggio dei Container
Il [Monitoraggio dei Container](https://kubernetes.io/docs/tasks/debug-application-cluster/resource-usage-monitoring/)
salva serie temporali di metriche generiche dei container in un database centrale e fornisce una interfaccia in cui navigare i dati stessi.
### Log a livello di Cluster
Un [log a livello di cluster](https://kubernetes.io/docs/concepts/cluster-administration/logging/)
è responsabile per il salvataggio dei log dei container in un log centralizzato la cui interfaccia permette di cercare e navigare nei log.
Voci correlate
--------------
* Scopri i concetti relativi ai [Nodi](https://kubernetes.io/docs/concepts/architecture/nodes/)
* Scopri i concetti relativi ai [Controller](https://kubernetes.io/it/docs/concepts/architecture/controller/)
* Scopri i concetti relativi al [kube-scheduler](https://kubernetes.io/docs/concepts/scheduling/kube-scheduler/)
* Leggi la [documentazione](https://etcd.io/docs/)
ufficiale di etcd
1.3 - Le API di Kubernetes
==========================
Le API di Kubernetes ti permettono di interrogare e manipolare lo stato degli oggetti in Kubernetes. Il cuore del Control Plane di Kubernetes è l'API server e le API HTTP che esso espone. Ogni entità o componente che si interfaccia con il cluster (gli utenti, le singole parti del tuo cluster, i componenti esterni), comunica attraverso l'API server.
Le convenzioni generali seguite dalle API sono descritte in [API conventions doc](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md)
.
Gli _endpoints_ delle API, la lista delle risorse esposte ed i relativi esempi sono descritti in [API Reference](https://kubernetes.io/docs/reference)
.
L'accesso alle API da remoto è discusso in [Controllare l'accesso alle API](https://kubernetes.io/docs/reference/access-authn-authz/controlling-access/)
.
Le API di Kubernetes servono anche come riferimento per lo schema dichiarativo della configurazione del sistema stesso. Il comando [kubectl](https://kubernetes.io/docs/reference/kubectl/overview/)
può essere usato per creare, aggiornare, cancellare ed ottenere le istanze delle risorse esposte attraverso le API.
Kubernetes assicura la persistenza del suo stato (al momento in [etcd](https://coreos.com/docs/distributed-configuration/getting-started-with-etcd/)
) usando la rappresentazione delle risorse implementata dalle API.
Kubernetes stesso è diviso in differenti componenti, i quali interagiscono tra loro attraverso le stesse API.
Evoluzione delle API
--------------------
In base alla nostra esperienza, ogni sistema di successo ha bisogno di evolvere ovvero deve estendersi aggiungendo funzionalità o modificare le esistenti per adattarle a nuovi casi d'uso. Le API di Kubernetes sono quindi destinate a cambiare e ad estendersi. In generale, ci si deve aspettare che nuove risorse vengano aggiunte di frequente cosi come nuovi campi possano altresì essere aggiunti a risorse esistenti. L'eliminazione di risorse o di campi devono seguire la [politica di deprecazione delle API](https://kubernetes.io/docs/reference/using-api/deprecation-policy/)
.
In cosa consiste una modifica compatibile e come modificare le API è descritto dal [API change document](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md)
.
Definizioni OpenAPI e Swagger
-----------------------------
La documentazione completa e dettagliata delle API è fornita attraverso la specifica [OpenAPI](https://www.openapis.org/)
.
Dalla versione 1.10 di Kubernetes, l'API server di Kubernetes espone le specifiche OpenAPI attraverso il seguente _endpoint_ `/openapi/v2`. Attraverso i seguenti _headers_ HTTP è possibile richiedere un formato specifico:
| Header | Possibili Valori |
| --- | --- |
| Accept | `application/json`, `application/com.github.proto-openapi.spec.v2@v1.0+protobuf` (il content-type di default è `application/json` per `*/*` ovvero questo header può anche essere omesso) |
| Accept-Encoding | `gzip` (questo header è facoltativo) |
Prima della versione 1.14, gli _endpoints_ che includono il formato del nome all'interno del segmento (`/swagger.json`, `/swagger-2.0.0.json`, `/swagger-2.0.0.pb-v1`, `/swagger-2.0.0.pb-v1.gz`) espongo le specifiche OpenAPI in formati differenti. Questi _endpoints_ sono deprecati, e saranno rimossi dalla versione 1.14 di Kubernetes.
**Esempi per ottenere le specifiche OpenAPI**:
| Prima della 1.10 | Dalla versione 1.10 di Kubernetes |
| --- | --- |
| GET /swagger.json | GET /openapi/v2 **Accept**: application/json |
| GET /swagger-2.0.0.pb-v1 | GET /openapi/v2 **Accept**: [application/com.github.proto-openapi.spec.v2@v1.0](mailto:application/com.github.proto-openapi.spec.v2@v1.0) +protobuf |
| GET /swagger-2.0.0.pb-v1.gz | GET /openapi/v2 **Accept**: [application/com.github.proto-openapi.spec.v2@v1.0](mailto:application/com.github.proto-openapi.spec.v2@v1.0) +protobuf **Accept-Encoding**: gzip |
Kubernetes implementa per le sue API anche una serializzazione alternativa basata sul formato Protobuf che è stato pensato principalmente per la comunicazione intra-cluster, documentato nella seguente [design proposal](https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/protobuf.md)
, e i files IDL per ciascun schema si trovano nei _Go packages_ che definisco i tipi delle API.
Prima della versione 1.14, l'_apiserver_ di Kubernetes espone anche un'_endpoint_, `/swaggerapi`, che può essere usato per ottenere le documentazione per le API di Kubernetes secondo le specifiche [Swagger v1.2](http://swagger.io/)
. Questo _endpoint_ è deprecato, ed è stato rimosso nella versione 1.14 di Kubernetes.
Versionamento delle API
-----------------------
Per facilitare l'eliminazione di campi specifici o la modifica della rappresentazione di una data risorsa, Kubernetes supporta molteplici versioni della stessa API disponibili attraverso differenti indirizzi, come ad esempio `/api/v1` oppure `/apis/extensions/v1beta1`.
Abbiamo deciso di versionare a livello di API piuttosto che a livello di risorsa o di campo per assicurare che una data API rappresenti una chiara, consistente vista delle risorse di sistema e dei sui comportamenti, e per abilitare un controllo degli accessi sia per le API in via di decommissionamento che per quelle sperimentali.
Si noti che il versionamento delle API ed il versionamento del Software sono indirettamente collegati. La [API and release versioning proposal](https://git.k8s.io/community/contributors/design-proposals/release/versioning.md)
descrive la relazione tra le versioni delle API ed le versioni del Software.
Differenti versioni delle API implicano differenti livelli di stabilità e supporto. I criteri per ciascuno livello sono descritti in dettaglio nella [API Changes documentation](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md#alpha-beta-and-stable-versions)
. Queste modifiche sono qui ricapitolate:
* Livello alpha:
* Il nome di versione contiene `alpha` (e.g. `v1alpha1`).
* Potrebbe contenere dei _bug_. Abilitare questa funzionalità potrebbe esporre al rischio di _bugs_. Disabilitata di default.
* Il supporto di questa funzionalità potrebbe essere rimosso in ogni momento senza previa notifica.
* Questa API potrebbe cambiare in modo incompatibile in rilasci futuri del Software e senza previa notifica.
* Se ne raccomandata l'utilizzo solo in _clusters_ di test creati per un breve periodo di vita, a causa di potenziali _bugs_ e delle mancanza di un supporto di lungo periodo.
* Livello beta:
* Il nome di versione contiene `beta` (e.g. `v2beta3`).
* Il codice è propriamente testato. Abilitare la funzionalità è considerato sicuro. Abilitata di default.
* Il supporto per la funzionalità nel suo complesso non sarà rimosso, tuttavia potrebbe subire delle modifiche.
* Lo schema e/o la semantica delle risorse potrebbe cambiare in modo incompatibile in successivi rilasci beta o stabili. Nel caso questo dovesse verificarsi, verrano fornite istruzioni per la migrazione alla versione successiva. Questo potrebbe richiedere la cancellazione, modifica, e la ri-creazione degli oggetti supportati da questa API. Questo processo di modifica potrebbe richiedere delle valutazioni. La modifica potrebbe richiedere un periodo di non disponibilità dell'applicazione che utilizza questa funzionalità.
* Raccomandata solo per applicazioni non critiche per la vostra impresa a causa dei potenziali cambiamenti incompatibili in rilasci successivi. Se avete più _clusters_ che possono essere aggiornati separatamente, potreste essere in grado di gestire meglio questa limitazione.
* **Per favore utilizzate le nostre versioni beta e forniteci riscontri relativamente ad esse! Una volta promosse a stabili, potrebbe non essere semplice apportare cambiamenti successivi.**
* Livello stabile:
* Il nome di versione è `vX` dove `X` è un intero.
* Le funzionalità relative alle versioni stabili continueranno ad essere presenti per parecchie versioni successive.
API groups
----------
Per facilitare l'estendibilità delle API di Kubernetes, sono stati implementati gli [_API groups_](https://git.k8s.io/community/contributors/design-proposals/api-machinery/api-group.md)
.
L'_API group_ è specificato nel percorso REST ed anche nel campo `apiVersion` di un oggetto serializzato.
Al momento ci sono diversi _API groups_ in uso:
1. Il gruppo _core_, spesso referenziato come il _legacy group_, è disponibile al percorso REST `/api/v1` ed utilizza `apiVersion: v1`.
2. I gruppi basati su un nome specifico sono disponibili attraverso il percorso REST `/apis/$GROUP_NAME/$VERSION`, ed usano `apiVersion: $GROUP_NAME/$VERSION` (e.g. `apiVersion: batch/v1`). La lista completa degli _API groups_ supportati e' descritta nel documento [Kubernetes API reference](https://kubernetes.io/docs/reference/)
.
Vi sono due modi per supportati per estendere le API attraverso le [_custom resources_](https://kubernetes.io/docs/concepts/api-extension/custom-resources/)
:
1. [CustomResourceDefinition](https://kubernetes.io/docs/tasks/access-kubernetes-api/extend-api-custom-resource-definitions/)
è pensato per utenti con esigenze CRUD basilari.
2. Utenti che necessitano di un nuovo completo set di API che utilizzi appieno la semantica di Kubernetes possono implementare il loro _apiserver_ ed utilizzare l'[_aggregator_](https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/)
per fornire ai propri utilizzatori la stessa esperienza a cui sono abituati con le API incluse nativamente in Kubernetes.
Abilitare o disabilitare gli _API groups_
-----------------------------------------
Alcune risorse ed _API groups_ sono abilitati di default. Questi posso essere abilitati o disabilitati attraverso il settaggio/flag `--runtime-config` applicato sull'_apiserver_. `--runtime-config` accetta valori separati da virgola. Per esempio: per disabilitare `batch/v1`, usa la seguente configurazione `--runtime-config=batch/v1=false`, per abilitare `batch/v2alpha1`, utilizzate `--runtime-config=batch/v2alpha1`.
Il _flag_ accetta set di coppie _chiave/valore_ separati da virgola che descrivono la configurazione a _runtime_ dell'_apiserver_.
#### Nota:
Abilitare o disabilitare risorse o gruppi richiede il riavvio dell'_apiserver_ e del _controller-manager_ affinché le modifiche specificate attraverso il flag `--runtime-config` abbiano effetto.
Abilitare specifiche risorse nel gruppo extensions/v1beta1
----------------------------------------------------------
DaemonSets, Deployments, StatefulSet, NetworkPolicies, PodSecurityPolicies e ReplicaSets presenti nel gruppo di API `extensions/v1beta1` sono disabilitate di default. Per esempio: per abilitare deployments and daemonsets, utilizza la seguente configurazione `--runtime-config=extensions/v1beta1/deployments=true,extensions/v1beta1/daemonsets=true`.
#### Nota:
Abilitare/disabilitare una singola risorsa è supportato solo per il gruppo di API `extensions/v1beta1` per ragioni storiche.
2 - Architettura di Kubernetes
==============================
2.1 - Comunicazione Control Plane - Nodo
========================================
Questo documento cataloga le connessioni tra il piano di controllo (_control-plane_), in realtà l'apiserver, e il cluster Kubernetes. L'intento è di consentire agli utenti di personalizzare la loro installazione per rafforzare la configurazione di rete affinché il cluster possa essere eseguito su una rete pubblica (o su IP completamente pubblici resi disponibili da un fornitore di servizi cloud).
Dal Nodo al control-plane
-------------------------
Kubernetes adotta un pattern per le API di tipo _"hub-and-spoke"_. Tutte le chiamate delle API eseguite sui vari nodi sono effettuate verso l'apiserver (nessuno degli altri componenti principali è progettato per esporre servizi remoti). L'apiserver è configurato per l'ascolto di connessioni remote su una porta HTTPS protetta (443) con una o più forme di [autenticazioni client](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)
abilitate. Si dovrebbero abilitare una o più forme di [autorizzazioni](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)
, in particolare nel caso in cui siano ammesse [richieste anonime](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#anonymous-requests)
o [_token_ legati ad un account di servizio (_service account_)](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#service-account-tokens)
.
Il certificato pubblico (_public root certificate_) relativo al cluster corrente deve essere fornito ai vari nodi di modo che questi possano connettersi in modo sicuro all'apiserver insieme alle credenziali valide per uno specifico _client_. Ad esempio, nella configurazione predefinita di un cluster [GKE](https://cloud.google.com/kubernetes-engine?hl=it)
, le credenziali del client fornite al kubelet hanno la forma di un certificato client. Si veda [inizializzazione TLS del kubelet TLS](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet-tls-bootstrapping/)
per la fornitura automatica dei certificati client al _kubelet_.
I Pod che desiderano connettersi all'apiserver possono farlo in modo sicuro sfruttando un account di servizio in modo che Kubernetes inserisca automaticamente il certificato pubblico di radice e un token valido al portatore (_bearer token_) all'interno Pod quando questo viene istanziato. In tutti i namespace è configurato un _Service_ con nome `kubernetes` con un indirizzo IP virtuale che viene reindirizzato (tramite _kube-proxy_) all'endpoint HTTPS dell'apiserver.
Anche i componenti del piano d controllo comunicano con l'apiserver del cluster su di una porta sicura esposta da quest'ultimo.
Di conseguenza, la modalità operativa predefinita per le connessioni dai nodi e dai Pod in esecuzione sui nodi verso il _control-plane_ è protetta da un'impostazione predefinita e può essere eseguita su reti non sicure e/o pubbliche.
Dal control-plane al nodo
-------------------------
Esistono due percorsi di comunicazione principali dal _control-plane_ (apiserver) verso i nodi. Il primo è dall'apiserver verso il processo _kubelet_ in esecuzione su ogni nodo nel cluster. Il secondo è dall'apiserver a ciascun nodo, Pod, o servizio attraverso la funzionalità proxy dell'apiserver.
### Dall'apiserver al _kubelet_
Le connessioni dall'apiserver al _kubelet_ vengono utilizzate per:
* Prendere i log relativi ai vari Pod.
* Collegarsi (attraverso kubectl) ai Pod in esecuzione.
* Fornire la funzionalità di _port-forwarding_ per i _kubelet_.
Queste connessioni terminano all'endpoint HTTPS del _kubelet_. Di default, l'apiserver non verifica il certificato servito dal _kubelet_, il che rende la connessione soggetta ad attacchi _man-in-the-middle_, e tale da essere considerato **non sicuro (unsafe)** se eseguito su reti non protette e/o pubbliche.
Per verificare questa connessione, si utilizzi il parametro `--kubelet-certificate-authority` al fine di fornire all'apiserver un insieme di certificati radice da utilizzare per verificare il il certificato servito dal _kubelet_.
Se questo non è possibile, si usi un [tunnel SSH](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/)
tra l'apiserver e il _kubelet_, se richiesto, per evitare il collegamento su una rete non protetta o pubblica.
In fine, l'[autenticazione e/o l'autorizzazione del kubelet](https://kubernetes.io/docs/admin/kubelet-authentication-authorization/)
dovrebbe essere abilitate per proteggere le API esposte dal _kubelet_.
### Dall'apiserver ai nodi, Pod, e servizi
Le connessioni dall'apiserver verso un nodo, Pod o servizio avvengono in modalità predefinita su semplice connessione HTTP e quindi non sono né autenticate né criptata. Queste connessioni possono essere eseguite su una connessione HTTPS sicura mediante il prefisso `https:` al nodo, Pod o nome del servizio nell'URL dell'API, ma non valideranno il certificato fornito dall'endpoint HTTPS né forniranno le credenziali del client così anche se la connessione verrà criptata, non fornirà alcuna garanzia di integrità. **Non è attualmente sicuro** eseguire queste connessioni su reti non protette e/o pubbliche.
### I tunnel SSH
Kubernetes supporta i _tunnel_ SSH per proteggere la comunicazione tra il _control-plane_ e i nodi. In questa configurazione, l'apiserver inizializza un tunnel SSH con ciascun nodo del cluster (collegandosi al server SSH in ascolto sulla porta 22) e fa passare tutto il traffico verso il _kubelet_, il nodo, il Pod, o il servizio attraverso questo tunnel. Questo tunnel assicura che il traffico non sia esposto al di fuori della rete su cui sono in esecuzioni i vari nodi.
I tunnel SSH sono al momento deprecati ovvero non dovrebbero essere utilizzati a meno che ci siano delle esigenze particolari. Il servizio `Konnectivity` è pensato per rimpiazzare questo canale di comunicazione.
### Il servizio _Konnectivity_
FEATURE STATE: `Kubernetes v1.18 [beta]`
Come rimpiazzo dei tunnel SSH, il servizio _Konnectivity_ fornisce un proxy a livello TCP per la comunicazione tra il _control-plane_ e il cluster. Il servizio _Konnectivity_ consiste in due parti: il _Konnectivity_ server e gli agenti _Konnectivity_, in esecuzione rispettivamente sul _control-plane_ e sui vari nodi. Gli agenti _Konnectivity_ inizializzano le connessioni verso il server _Konnectivity_ e mantengono le connessioni di rete. Una volta abilitato il servizio _Konnectivity_, tutto il traffico tra il _control-plane_ e i nodi passa attraverso queste connessioni.
Si può fare riferimento al [tutorial per il servizio _Konnectivity_](https://kubernetes.io/docs/tasks/extend-kubernetes/setup-konnectivity/)
per configurare il servizio _Konnectivity_ all'interno del cluster
2.2 - Concetti alla base del Cloud Controller Manager
=====================================================
Il concetto di CCM (cloud controller manager), da non confondere con il binario, è stato originariamente creato per consentire di sviluppare Kubernetes indipendentemente dall'implementazione dello specifico cloud provider. Il cloud controller manager viene eseguito insieme ad altri componenti principali come il Kubernetes controller manager, il server API e lo scheduler. Può anche essere avviato come addon di Kubernetes, nel qual caso viene eseguito su Kubernetes.
Il design del cloud controller manager è basato su un meccanismo di plug-in che consente ai nuovi provider cloud di integrarsi facilmente con Kubernetes creando un plug-in. Sono in atto programmi per l'aggiunta di nuovi provider di cloud su Kubernetes e per la migrazione dei provider che usano il vecchio metodo a questo nuovo metodo.
Questo documento discute i concetti alla base del cloud controller manager e fornisce dettagli sulle funzioni associate.
Ecco l'architettura di un cluster Kubernetes senza il gestore del controller cloud:

Architettura
------------
Nel diagramma precedente, Kubernetes e il provider cloud sono integrati attraverso diversi componenti:
* Kubelet
* Kubernetes controller manager
* Kubernetes API server
Il CCM consolida tutta la logica dipendente dal cloud presente nei tre componenti precedenti, per creare un singolo punto di integrazione con il cloud. La nuova architettura con il CCM si presenta così:

Componenti del CCM
------------------
Il CCM divide alcune funzionalità del Kubernetes controller manager (KCM) e le esegue in un differente processo. In particolare, toglie dal KCM le integrazioni con il cloud specifico. Il KCM ha i seguenti controller che dipendono dal cloud specifico:
* Node controller
* Volume controller
* Route controller
* Service controller
Nella versione 1.9, il CCM esegue i seguenti controller dall'elenco precedente:
* Node controller
* Route controller
* Service controller
#### Nota:
È stato deliberatamente deciso di non spostare il Volume controller nel CCM. Data la complessità del Volume controller e gli sforzi già fatti per astrarre le logiche specifiche dei singoli fornitori, è stato deciso che il Volume controller non verrà spostato nel CCM.
Il piano originale per supportare i volumi utilizzando il CCM era di utilizzare [Flex](https://kubernetes.io/docs/concepts/storage/volumes/#flexVolume)
per supportare volumi collegabili. Tuttavia, una implementazione parallela, nota come [CSI](https://kubernetes.io/docs/concepts/storage/volumes/#csi)
è stata designata per sostituire Flex.
Considerando queste evoluzioni, abbiamo deciso di adottare un approccio intermedio finché il CSI non è pronto.
Funzioni del CCM
----------------
Il CCM eredita le sue funzioni da componenti di Kubernetes che dipendono da uno specifico provider di cloud. Questa sezione è strutturata sulla base di tali componenti.
### 1\. Kubernetes controller manager
La maggior parte delle funzioni del CCM deriva dal KCM. Come menzionato nella sezione precedente, CCM esegue i seguenti cicli di controllo:
* Node controller
* Route controller
* Service controller
#### Node controller
Il Node controller è responsabile per l'inizializzazione di un nodo ottenendo informazioni sui nodi in esecuzione nel cluster dal provider cloud. Il controller del nodo esegue le seguenti funzioni:
1. Inizializzare un nodo con le label zone/region specifiche per il cloud in uso.
2. Inizializzare un nodo con le specifiche, ad esempio, tipo e dimensione specifiche del cloud in uso.
3. Ottenere gli indirizzi di rete del nodo e l'hostname.
4. Nel caso in cui un nodo non risponda, controlla il cloud per vedere se il nodo è stato cancellato dal cloud. Se il nodo è stato eliminato dal cloud, elimina l'oggetto Nodo di Kubernetes.
#### Route controller
Il Route controller è responsabile della configurazione delle route nel cloud in modo che i container su nodi differenti del cluster Kubernetes possano comunicare tra loro. Il Route controller è utilizzabile solo dai cluster su Google Compute Engine.
#### Service Controller
Il Service Controller rimane in ascolto per eventi di creazione, aggiornamento ed eliminazione di servizi. In base allo stato attuale dei servizi in Kubernetes, configura i bilanciatori di carico forniti dal cloud (come gli ELB, i Google LB, o gli Oracle Cloud Infrastructure LB) per riflettere lo stato dei servizi in Kubernetes. Inoltre, assicura che i back-end dei bilanciatori di carico forniti dal cloud siano aggiornati.
### 2\. Kubelet
Il Node Controller contiene l'implementazione dipendente dal cloud della kubelet. Prima dell'introduzione del CCM, la kubelet era responsabile dell'inizializzazione di un nodo con dettagli dipendenti dallo specifico cloud come gli indirizzi IP, le label region/zone e le informazioni sul tipo di istanza. L'introduzione del CCM ha spostato questa operazione di inizializzazione dalla kubelet al CCM.
In questo nuovo modello, la kubelet inizializza un nodo senza informazioni specifiche del cloud. Tuttavia, aggiunge un blocco al nodo appena creato che rende il nodo non selezionabile per eseguire container finché il CCM non inizializza il nodo con le informazioni specifiche del cloud. Il CCM rimuove quindi questo blocco.
Sistema a plug-in
-----------------
Il cloud controller manager utilizza le interfacce di Go per consentire l'implementazione di implementazioni di qualsiasi cloud. In particolare, utilizza l'interfaccia CloudProvider definita [qui](https://github.com/kubernetes/cloud-provider/blob/9b77dc1c384685cb732b3025ed5689dd597a5971/cloud.go#L42-L62)
.
L'implementazione dei quattro controller generici evidenziati sopra, alcune strutture, l'interfaccia cloudprovider condivisa rimarranno nel core di Kubernetes. Le implementazioni specifiche per i vari cloud saranno costruite al di fuori del core e implementeranno le interfacce definite nel core.
Per ulteriori informazioni sullo sviluppo di plug-in, consultare [Developing Cloud Controller Manager](https://kubernetes.io/docs/tasks/administer-cluster/developing-cloud-controller-manager/)
.
Autorizzazione
--------------
Questa sezione dettaglia l'accesso richiesto dal CCM sui vari API objects per eseguire le sue operazioni.
### Node controller
Il Node controller funziona solo con oggetti di tipo Node. Richiede l'accesso completo per ottenere, elencare, creare, aggiornare, applicare patch, guardare ed eliminare oggetti di tipo Node.
v1/Node:
* Get
* List
* Create
* Update
* Patch
* Watch
* Delete
### Route controller
Il Route controller ascolta la creazione dell'oggetto Node e configura le rotte in modo appropriato. Richiede l'accesso in lettura agli oggetti di tipo Node.
v1/Node:
* Get
### Service controller
Il Service controller resta in ascolto per eventi di creazione, aggiornamento ed eliminazione di oggetti di tipo Servizi, e configura gli endpoint per tali Servizi in modo appropriato.
Per accedere ai Servizi, è necessario il permesso per list e watch. Per aggiornare i Servizi, sono necessari i permessi patch e update.
Per impostare gli endpoint per i Servizi, richiede i permessi create, list, get, watch, e update.
v1/Service:
* List
* Get
* Watch
* Patch
* Update
### Others
L'implementazione del core di CCM richiede l'accesso per creare eventi e, per garantire operazioni sicure, richiede l'accesso per creare ServiceAccounts.
v1/Event:
* Create
* Patch
* Update
v1/ServiceAccount:
* Create
L'RBAC ClusterRole per il CCM ha il seguente aspetto:
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: cloud-controller-manager
rules:
- apiGroups:
- ""
resources:
- events
verbs:
- create
- patch
- update
- apiGroups:
- ""
resources:
- nodes
verbs:
- '*'
- apiGroups:
- ""
resources:
- nodes/status
verbs:
- patch
- apiGroups:
- ""
resources:
- services
verbs:
- list
- patch
- update
- watch
- apiGroups:
- ""
resources:
- serviceaccounts
verbs:
- create
- apiGroups:
- ""
resources:
- persistentvolumes
verbs:
- get
- list
- update
- watch
- apiGroups:
- ""
resources:
- endpoints
verbs:
- create
- get
- list
- watch
- update
Vendor Implementations
----------------------
I seguenti fornitori di cloud hanno una implementazione di CCM:
* [Alibaba Cloud](https://github.com/kubernetes/cloud-provider-alibaba-cloud)
* [AWS](https://github.com/kubernetes/cloud-provider-aws)
* [Azure](https://github.com/kubernetes/cloud-provider-azure)
* [BaiduCloud](https://github.com/baidu/cloud-provider-baiducloud)
* [DigitalOcean](https://github.com/digitalocean/digitalocean-cloud-controller-manager)
* [GCP](https://github.com/kubernetes/cloud-provider-gcp)
* [Hetzner](https://github.com/hetznercloud/hcloud-cloud-controller-manager)
* [Linode](https://github.com/linode/linode-cloud-controller-manager)
* [OpenStack](https://github.com/kubernetes/cloud-provider-openstack)
* [Oracle](https://github.com/oracle/oci-cloud-controller-manager)
* [TencentCloud](https://github.com/TencentCloud/tencentcloud-cloud-controller-manager)
Cluster Administration
----------------------
Le istruzioni complete per la configurazione e l'esecuzione del CCM sono fornite [qui](https://kubernetes.io/docs/tasks/administer-cluster/running-cloud-controller/#cloud-controller-manager)
.
2.3 - Controller
================
Nella robotica e nell'automazione, un _circuito di controllo_ (_control loop_) è un un'iterazione senza soluzione di continuità che regola lo stato di un sistema.
Ecco un esempio di un circuito di controllo: il termostato di una stanza.
Quando viene impostata la temperatura, si definisce attraverso il termostato lo _stato desiderato_. L'attuale temperatura nella stanza è invece lo _stato corrente_. Il termostato agisce per portare lo stato corrente il più vicino possibile allo stato desiderato accendendo e spegnendo le apparecchiature.
In Kubernetes, i _controller_ sono circuiti di controllo che osservano lo stato del [cluster](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-cluster "Un'insieme di macchine, chiamate nodi, che eseguono container gestiti da Kubernetes. Un cluster ha almeno un Worker Node.")
, e apportano o richiedono modifiche quando necessario. Ogni _controller_ prova a portare lo stato corrente del cluster verso lo stato desiderato.
Il modello del controller
-------------------------
Un _controller_ monitora almeno una tipo di risorsa registrata in Kubernetes. Questi [oggetti](https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/#kubernetes-objects)
hanno una proprietà chiamata _spec_ (specifica) che rappresenta lo stato desiderato. Il o i _controller_ per quella risorsa sono responsabili di mantenere lo stato corrente il più simile possibile rispetto allo stato desiderato.
Il _controller_ potrebbe eseguire l'azione relativa alla risorsa in questione da sé; più comunemente, in Kubernetes, un _controller_ invia messaggi all'[API server](https://kubernetes.io/it/docs/concepts/architecture/#kube-apiserver "Componente della Control plane che serve le Kubernetes API.")
che a sua volta li rende disponibili ad altri componenti nel cluster. Di seguito troverete esempi per questo scenario.
### Controllo attraverso l'API server
Il [Job](https://kubernetes.io/it/docs/concepts/workloads/controllers/jobs-run-to-completion "Uno o più lavori (task) che vengono eseguiti fino al loro completamento.")
_controller_ è un esempio di un _controller_ nativo in Kubernetes. I _controller_ nativi gestiscono lo stato interagendo con l'API server presente nel cluster.
Il Job è una risorsa di Kubernetes che lancia uno o più [Pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
per eseguire un lavoro (task) e poi fermarsi.
(Una volta che è stato [schedulato](https://kubernetes.io/docs/concepts/scheduling-eviction/)
, un oggetto _Pod_ diventa parte dello stato desisderato di un dato _kubelet_).
Quando il Job _controller_ vede un nuovo lavoro da svolgere si assicura che, da qualche parte nel cluster, i _kubelet_ anche sparsi su più nodi eseguano il numero corretto di _Pod_ necessari per eseguire il lavoro richiesto. Il Job _controller_ non esegue direttamente alcun _Pod_ o _container_ bensì chiede all'API server di creare o rimuovere i _Pod_. Altri componenti appartenenti al [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
reagiscono in base alle nuove informazioni (ci sono nuovi _Pod_ da creare e gestire) e cooperano al completamento del job.
Dopo che un nuovo Job è stato creato, lo stato desiderato per quel Job è il suo completamento. Il Job _controller_ fa sì che lo stato corrente per quel Job sia il più vicino possibile allo stato desiderato: creare _Pod_ che eseguano il lavoro che deve essere effettuato attraverso il Job, così che il Job sia prossimo al completamento.
I _controller_ aggiornano anche gli oggetti che hanno configurato. Ad esempio: una volta che il lavoro relativo ad un dato Job è stato completato, il Job _controller_ aggiorna l'oggetto Job segnandolo come `Finished`.
(Questo è simile allo scenario del termostato che spegne un certo led per indicare che ora la stanza ha raggiungo la temperatura impostata)
### Controllo diretto
A differenza del Job, alcuni _controller_ devono eseguire delle modifiche a parti esterne al cluster.
Per esempio, se viene usato un circuito di controllo per assicurare che ci sia un numero sufficiente di [Nodi](https://kubernetes.io/it/docs/concepts/architecture/nodes/ "Un node è una macchina worker in Kubernetes.")
nel cluster, allora il _controller_ ha bisogno che qualcosa al di fuori del cluster configuri i nuovi _Nodi_ quando sarà necessario.
I _controller_ che interagiscono con un sistema esterno trovano il loro stato desiderato attraverso l'API server, quindi comunicano direttamente con un sistema esterno per portare il loro stato corrente più in linea possibile con lo stato desiderato
(In realtà c'è un _controller_ che scala orizzontalmente i nodi nel cluster. Vedi [Cluster autoscaling](https://kubernetes.io/docs/tasks/administer-cluster/cluster-management/#cluster-autoscaling)
).
Stato desiderato versus corrente
--------------------------------
Kubernetes ha una visione _cloud-native_ dei sistemi, ed è in grado di gestire continue modifiche.
Il cluster viene modificato continuamente durante la sua attività ed il _circuito di controllo_ è in grado di risolvere automaticamente i possibili guasti.
Fino a che i _controller_ del cluster sono in funzione ed in grado di apportare le dovute modifiche, non è rilevante che lo stato complessivo del cluster sia o meno stabile.
Progettazione
-------------
Come cardine della sua progettazione, Kubernetes usa vari _controller_ ognuno dei quali è responsabile per un particolare aspetto dello stato del cluster. Più comunemente, un dato _circuito di controllo_ (_controller_) usa un tipo di risorsa per il suo stato desiderato, ed utilizza anche risorse di altro tipo per raggiungere questo stato desiderato. Per esempio il Job _controller_ tiene traccia degli oggetti di tipo _Job_ (per scoprire nuove attività da eseguire) e degli oggetti di tipo _Pod_ (questi ultimi usati per eseguire i _Job_, e quindi per controllare quando il loro lavoro è terminato). In questo caso, qualcos'altro crea i _Job_, mentre il _Job_ _controller_ crea i _Pod_.
È utile avere semplici _controller_ piuttosto che un unico, monolitico, _circuito di controllo_. I _controller_ possono guastarsi, quindi Kubernetes è stato disegnato per gestire questa eventualità.
#### Nota:
Ci possono essere diversi _controller_ che creato o aggiornano lo stesso tipo di oggetti. Dietro le quinte, i _controller_ di Kubernetes si preoccupano esclusivamente delle risorse (di altro tipo) collegate alla risorsa primaria da essi controllata.
Per esempio, si possono avere _Deployment_ e _Job_; entrambe creano _Pod_. Il Job _controller_ non distrugge i _Pod_ creati da un _Deployment_, perché ci sono informazioni (_[labels](https://kubernetes.io/it/docs/concepts/overview/working-with-objects/labels "Tags di oggetti con attributi identificativi che sono significativi e pertinenti per gli utenti.")
_) che vengono usate dal _controller_ per distinguere i _Pod_.
I modi per eseguire i _controller_
----------------------------------
Kubernetes annovera un insieme di _controller_ nativi che sono in esecuzione all'interno del [kube-controller-manager](https://kubernetes.io/it/docs/reference/command-line-tools-reference/kube-controller-manager/ "Componente della Control Plane che gestisce i controller.")
. Questi _controller_ nativi forniscono importanti funzionalità di base.
Il Deployment _controller_ ed il Job _controller_ sono esempi di _controller_ che vengono forniti direttamente da Kubernetes stesso (ovvero _controller_ "nativi"). Kubernetes consente di eseguire un _piano di controllo_(_control plane_) resiliente, di modo che se un dei _controller_ nativi dovesse fallire, un'altra parte del piano di controllo si occuperà di eseguire quel lavoro.
Al fine di estendere Kubernetes, si possono avere _controller_ in esecuzione al di fuori del piano di controllo. Oppure, se si desidera, è possibile scriversi un nuovo _controller_. È possibile eseguire il proprio controller come una serie di _Pod_, oppure esternamente rispetto a Kubernetes. Quale sia la soluzione migliore, dipende dalla responsabilità di un dato controller.
Voci correlate
--------------
* Leggi in merito [Kubernetes control plane](https://kubernetes.io/it/docs/concepts/#kubernetes-control-plane)
* Scopri alcune delle basi degli [oggetti di Kubernetes](https://kubernetes.io/it/docs/concepts/#kubernetes-objects)
* Per saperne di più riguardo alle [API di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/kubernetes-api/)
* Se vuoi creare un tuo _controller_, guarda [i modelli per l'estensibilità](https://kubernetes.io/docs/concepts/extend-kubernetes/extend-cluster/#extension-patterns)
in Estendere Kubernetes.
3 - Containers
==============
La tecnologia per distribuire un'applicazione insieme con le dipendenze necessarie per la sua esecuzione.
Ogni _container_ che viene eseguito è riproducibile; la pratica di includere le dipendenze all'interno di ciascuno _container_ permette di ottenere sempre lo stesso risultato ad ogni esecuzione del medesimo _container_.
I _Container_ permettono di disaccoppiare le applicazioni dall'infrastruttura del host su cui vengono eseguite. Questo approccio rende più facile il _deployment_ su cloud o sitemi operativi differenti tra loro.
Immagine di container
---------------------
L'[immagine di un container](https://kubernetes.io/it/docs/concepts/containers/images/)
e' un pacchetto software che contiene tutto ciò che serve per eseguire un'applicazione: il codice sorgente e ciascun _runtime_ necessario, librerie applicative e di sistema, e le impostazioni predefinite per ogni configurazione necessaria.
Un _container_ è immutabile per definizione: non è possibile modificare il codice di un _container_ in esecuzione. Se si ha un'applicazione containerizzata e la si vuole modificare, si deve costruire un nuovo _container_ che includa il cambiamento desiderato, e quindi ricreare il _container_ partendo dalla nuova immagine aggiornata.
Container runtimes
------------------
Il container runtime è il software che è responsabile per l'esecuzione dei container.
Kubernetes supporta diversi container runtimes: [Docker](http://www.docker.com/)
, [containerd](https://containerd.io/)
, [cri-o](https://cri-o.io/)
, [rktlet](https://github.com/kubernetes-incubator/rktlet)
e tutte le implementazioni di [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Voci correlate
--------------
* Leggi in merito [immagine di container](https://kubernetes.io/it/docs/concepts/containers/images/)
* Leggi in merito [Pods](https://kubernetes.io/docs/concepts/workloads/pods/)
3.1 - Immagini
==============
L'immagine di un container rappresenta dati binari che incapsulano un'applicazione e tutte le sue dipendenze software. Le immagini sono costituite da pacchetti software eseguibili che possono essere avviati in modalità standalone e su cui si possono fare ipotesi ben precise circa l'ambiente in cui vengono eseguiti.
Tipicamente viene creata un'immagine di un'applicazione ed effettuato il _push_ su un registry (un repository pubblico di immagini) prima di poterne fare riferimento esplicito in un [Pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
Questa pagina va a delineare nello specifico il concetto di immagine di un container.
I nomi delle immagini
---------------------
Alle immagini dei container vengono normalmente attribuiti nomi come `pause`, `example/mycontainer`, o `kube-apiserver`. Le immagini possono anche contenere l'hostname del registry in cui le immagini sono pubblicate; ad esempio: `registro.fittizio.esempio/nomeimmagine`, ed è possibile che sia incluso nel nome anche il numero della porta; ad esempio: `registro.fittizio.esempio:10443/nomeimmagine`.
Se non si specifica l'hostname di un registry, Kubernetes assume che ci si riferisca al registry pubblico di Docker.
Dopo la parte relativa al nome dell'immagine si può aggiungere un _tag_ (come comunemente avviene per comandi come `docker` e `podman`). I tag permettono l'identificazione di differenti versioni della stessa serie di immagini.
I tag delle immagini sono composti da lettere minuscole e maiuscole, numeri, underscore (`_`), punti (`.`), e trattini (`-`).
Esistono regole aggiuntive relative a dove i caratteri separatori (`_`, `-`, and `.`) possano essere inseriti nel tag di un'immagine. Se non si specifica un tag, Kubernetes assume il tag `latest` che va a definire l'immagine disponibile più recente.
#### Attenzione:
Evitate di utilizzare il tag `latest` quando si rilasciano dei container in produzione, in quanto risulta difficile tracciare quale versione dell'immagine sia stata avviata e persino più difficile effettuare un rollback ad una versione precente.
Invece, meglio specificare un tag specifico come ad esempio `v1.42.0`.
Aggiornamento delle immagini
----------------------------
Quando un [Deployment](https://kubernetes.io/it/docs/concepts/workloads/controllers/deployment/ "Gestisce una applicazione replicata nel tuo cluster.")
, [StatefulSet](https://kubernetes.io/it/docs/concepts/workloads/controllers/statefulset/ "Gestisce deployment e la scalabilità di un gruppo di Pod, con storage e identificativi persistenti per ogni Pod.")
, Pod, o qualsiasi altro oggetto che includa un Pod template viene creato per la prima volta, la policy di default per il pull di tutti i container nel Pod è impostata su `IfNotPresent` (se non presente) se non specificato diversamente. Questa policy permette al [kubelet](https://kubernetes.io/it/docs/reference/generated/kubelet "Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.")
di evitare di fare il pull di un'immagine se questa è già presente.
Se necessario, si può forzare il pull in ogni occasione in uno dei seguenti modi:
* impostando `imagePullPolicy` (specifica per il pull delle immagini) del container su `Always` (sempre).
* omettendo `imagePullPolicy` ed usando il tag `:latest` (più recente) per l'immagine da utilizzare; Kubernetes imposterà la policy su `Always` (sempre).
* omettendo `imagePullPolicy` ed il tag per l'immagine da utilizzare.
* abilitando l'admission controller [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
.
#### Nota:
Il valore dell'impostazione `imagePullPolicy` del container è sempre presente quando l'oggetto viene creato per la prima volta e non viene aggiornato se il tag dell'immagine dovesse cambiare successivamente.
Ad esempio, creando un Deployment con un'immagine il cui tag _non_ è `:latest`, e successivamente aggiornando il tag di quell'immagine a `:latest`, il campo `imagePullPolicy` _non_ cambierà su `Always`. È necessario modificare manualmente la policy di pull di ogni oggetto dopo la sua creazione.
Quando `imagePullPolicy` è definito senza un valore specifico, esso è impostato su `Always`.
Multi-architecture support nelle immagini
-----------------------------------------
Oltre a fornire immagini binarie, un _container registry_ può fornire un [indice delle immagini disponibili per un container](https://github.com/opencontainers/image-spec/blob/master/image-index.md)
. L'indice di un'immagine può puntare a più [file manifest](https://github.com/opencontainers/image-spec/blob/master/manifest.md)
ciascuno per una versione specifica dell'architettura di un container. L'idea è che si può avere un unico nome per una stessa immagine (ad esempio: `pause`, `example/mycontainer`, `kube-apiserver`) e permettere a diversi sistemi di recuperare l'immagine binaria corretta a seconda dell'architettura della macchina che la sta utilizzando.
Kubernetes stesso tipicamente nomina le immagini dei container tramite il suffisso `-$(ARCH)`. Per la garantire la retrocompatibilità è meglio generare le vecchie immagini con dei suffissi. L'idea è quella di generare, ad esempio, l'immagine `pause` con un manifest che include tutte le architetture supportate, affiancata, ad esempio, da `pause-amd64` che è retrocompatibile per le vecchie configurazioni o per quei file YAML in cui sono specificate le immagini con i suffissi.
Utilizzare un private registry
------------------------------
I private registry possono richiedere l'utilizzo di chiavi per accedere alle immagini in essi contenute.
Le credenziali possono essere fornite in molti modi:
* configurando i nodi in modo tale da autenticarsi al private registry
* tutti i pod possono acquisire informazioni da qualsiasi private registry configurato
* è necessario che l'amministratore del cluster configuri i nodi in tal senso
* tramite pre-pulled images (immagini pre-caricate sui nodi)
* tutti i pod possono accedere alle immagini salvate sulla cache del nodo a cui si riferiscono
* è necessario effettuare l'accesso come root di sistema su ogni nodo per inserire questa impostazione
* specificando _ImagePullSecrets_ su un determinato pod
* solo i pod che forniscono le proprie chiavi hanno la possibilità di accedere al private registry
* tramite estensioni locali o specifiche di un _Vendor_
* se si sta utilizzando una configurazione personalizzata del nodo oppure se manualmente, o tramite il _cloud provider_, si implementa un meccanismo di autenticazione del nodo presso il _container registry_.
Di seguito la spiegazione dettagliata di queste opzioni.
### Configurazione dei nodi per l'autenticazione ad un private registry
Se si sta utilizzando Docker sui nodi, si può configurare il _Docker container runtime_ per autenticare il nodo presso un private container registry.
Questo è un approccio possibile se si ha il controllo sulle configurazioni del nodo.
#### Nota:
Kubernetes di default supporta solo le sezioni `auths` e `HttpHeaders` nelle configurazioni relative a Docker. Eventuali _helper_ per le credenziali di Docker (`credHelpers` o `credsStore`) non sono supportati.
Docker salva le chiavi per i registri privati in `$HOME/.dockercfg` oppure nel file `$HOME/.docker/config.json`. Inserendo lo stesso file nella lista seguente, kubelet lo utilizzerà per recuperare le credenziali quando deve fare il _pull_ delle immagini.
* `{--root-dir:-/var/lib/kubelet}/config.json`
* `{cwd of kubelet}/config.json`
* `${HOME}/.docker/config.json`
* `/.docker/config.json`
* `{--root-dir:-/var/lib/kubelet}/.dockercfg`
* `{cwd of kubelet}/.dockercfg`
* `${HOME}/.dockercfg`
* `/.dockercfg`
#### Nota:
Potrebbe essere necessario impostare `HOME=/root` esplicitamente come variabile d'ambiente del processo _kubelet_.
Di seguito i passi consigliati per configurare l'utilizzo di un private registry da parte dei nodi del _cluster_. In questo esempio, eseguire i seguenti comandi sul proprio desktop/laptop:
1. Esegui `docker login [server]` per ogni _set_ di credenziali che vuoi utilizzare. Questo comando aggiornerà `$HOME/.docker/config.json` sul tuo PC.
2. Controlla il file `$HOME/.docker/config.json` in un editor di testo per assicurarti che contenga le credenziali che tu voglia utilizzare.
3. Recupera la lista dei tuoi nodi; ad esempio:
* se vuoi utilizzare i nomi: `nodes=$( kubectl get nodes -o jsonpath='{range.items[*].metadata}{.name} {end}' )`
* se vuoi recuperare gli indirizzi IP: `nodes=$( kubectl get nodes -o jsonpath='{range .items[*].status.addresses[?(@.type=="ExternalIP")]}{.address} {end}' )`
4. Copia il tuo file locale `.docker/config.json` in uno dei path sopra riportati nella lista di ricerca.
* ad esempio, per testare il tutto: `for n in $nodes; do scp ~/.docker/config.json root@"$n":/var/lib/kubelet/config.json; done`
#### Nota:
Per i cluster di produzione, utilizza un configuration management tool per poter applicare le impostazioni su tutti i nodi laddove necessario.
Puoi fare una verifica creando un Pod che faccia uso di un'immagine privata; ad esempio:
kubectl apply -f - < --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL
Se possiedi il file delle credenziali per Docker, anziché utilizzare il comando quì sopra puoi importare il file di credenziali come un Kubernetes [Secrets](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-secret "Contiene informazioni sensibili, come passwords, token OAuth, e chiavi ssh.")
.
[Creare un Secret a partire da credenziali Docker](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/#registry-secret-existing-credentials)
fornisce la spiegazione dettagliata su come fare.
Ciò è particolarmente utile se si utilizzano più _container registry_ privati, in quanto il comando `kubectl create secret docker-registry` genera un Secret che funziona con un solo private registry.
#### Nota:
I Pod possono fare riferimento ai Secret per il pull delle immagini soltanto nel proprio _namespace_, quindi questo procedimento deve essere svolto per ogni _namespace_.
#### Fare riferimento ad imagePullSecrets in un Pod
È possibile creare pod che referenzino quel Secret aggiungendo la sezione `imagePullSecrets` alla definizione del Pod.
Ad esempio:
cat < pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: foo
namespace: awesomeapps
spec:
containers:
- name: foo
image: janedoe/awesomeapp:v1
imagePullSecrets:
- name: myregistrykey
EOF
cat <> ./kustomization.yaml
resources:
- pod.yaml
EOF
Questo deve esser fatto per ogni Pod che utilizzi un private registry.
Comunque, le impostazioni relative a questo campo possono essere automatizzate inserendo la sezione _imagePullSecrets_ nella definizione della risorsa [ServiceAccount](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/)
.
Visitare la pagina [Aggiungere ImagePullSecrets ad un Service Account](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#add-imagepullsecrets-to-a-service-account)
per istruzioni più dettagliate.
Puoi utilizzarlo in congiunzione al file `.docker/config.json` configurato per ogni nodo. In questo caso, si applicherà un _merge_ delle credenziali.
Casi d'uso
----------
Ci sono varie soluzioni per configurare i private registry. Di seguito, alcuni casi d'uso comuni e le soluzioni suggerite.
1. Cluster in cui sono utilizzate soltanto immagini non proprietarie (ovvero _open-source_). In questo caso non sussiste il bisogno di nascondere le immagini.
* Utilizza immagini pubbliche da Docker hub.
* Nessuna configurazione richiesta.
* Alcuni _cloud provider_ mettono in _cache_ o effettuano il _mirror_ di immagini pubbliche, il che migliora la disponibilità delle immagini e ne riduce il tempo di _pull_.
2. Cluster con container avviati a partire da immagini proprietarie che dovrebbero essere nascoste a chi è esterno all'organizzazione, ma visibili a tutti gli utenti abilitati nel cluster.
* Utilizza un private [Docker registry](https://docs.docker.com/registry/)
.
* Esso può essere ospitato da [Docker Hub](https://hub.docker.com/signup)
, o da qualche altra piattaforma.
* Configura manualmente il file .docker/config.json su ogni nodo come descritto sopra.
* Oppure, avvia un private registry dietro il tuo firewall con accesso in lettura libero.
* Non è necessaria alcuna configurazione di Kubernetes.
* Utilizza un servizio di _container registry_ che controlli l'accesso alle immagini
* Esso funzionerà meglio con una configurazione del cluster basata su _autoscaling_ che con una configurazione manuale del nodo.
* Oppure, su un cluster dove la modifica delle configurazioni del nodo non è conveniente, utilizza `imagePullSecrets`.
3. Cluster con immagini proprietarie, alcune delle quali richiedono un controllo sugli accessi.
* Assicurati che l'_admission controller_ [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
sia attivo. Altrimenti, tutti i Pod potenzialmente possono avere accesso a tutte le immagini.
* Sposta i dati sensibili un un _Secret_, invece di inserirli in un'immagine.
4. Un cluster multi-tenant dove ogni tenant necessiti di un private registry.
* Assicurati che l'_admission controller_ [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
sia attivo. Altrimenti, tutti i Pod di tutti i tenant potrebbero potenzialmente avere accesso a tutte le immagini.
* Avvia un private registry che richieda un'autorizzazione all'accesso.
* Genera delle credenziali di registry per ogni tenant, inseriscile in dei _Secret_, e popola i _Secret_ per ogni _namespace_ relativo ad ognuno dei tenant.
* Il singolo tenant aggiunge così quel _Secret_ all'impostazione _imagePullSecrets_ di ogni _namespace_.
Se si ha la necessità di accedere a più registri, si può generare un _Secret_ per ognuno di essi. Kubelet farà il _merge_ di ogni `imagePullSecrets` in un singolo file virtuale `.docker/config.json`.
Voci correlate
--------------
* Leggi [OCI Image Manifest Specification](https://github.com/opencontainers/image-spec/blob/master/manifest.md)
3.2 - Container Environment
===========================
Questa pagina descrive le risorse disponibili nei Container eseguiti in Kubernetes.
Container environment
---------------------
Quando si esegue un Container in Kubernetes, le seguenti risorse sono rese disponibili:
* Un filesystem, composto dal file system dell'[image](https://kubernetes.io/it/docs/concepts/containers/images/)
e da uno o più [volumes](https://kubernetes.io/docs/concepts/storage/volumes/)
.
* Una serie di informazioni sul Container stesso.
* Una serie di informazioni sugli oggetti nel cluster.
### Informazioni sul Container
L' _hostname_ di un Container è il nome del Pod all'interno del quale è eseguito il Container. È consultabile tramite il comando `hostname` o tramite la funzione [`gethostname`](http://man7.org/linux/man-pages/man2/gethostname.2.html)
disponibile in libc.
Il nome del Pod e il namespace possono essere resi disponibili come environment variables attraverso l'uso delle [downward API](https://kubernetes.io/docs/tasks/inject-data-application/downward-api-volume-expose-pod-information/)
.
Gli utenti possono aggiungere altre environment variables nella definizione del Pod; anche queste saranno disponibili nel Container come tutte le altre environment variables definite staticamente nella Docker image.
### Informazioni sul cluster
Al momento della creazione del Container è generata una serie di environment variables con la lista di servizi in esecuzione nel cluster. Queste environment variables rispettano la sintassi dei Docker links.
Per un servizio chiamato _foo_ che è in esecuzione in un Container di nome _bar_, le seguenti variabili sono generate:
FOO_SERVICE_HOST=
FOO_SERVICE_PORT=
I servizi hanno un indirizzo IP dedicato e sono disponibili nei Container anche via DNS se il [DNS addon](http://releases.k8s.io/master/cluster/addons/dns/)
è installato nel cluster.
Voci correlate
--------------
* Approfondisci [Container lifecycle hooks](https://kubernetes.io/it/docs/concepts/containers/container-lifecycle-hooks/)
.
* Esegui un tutorial su come [definire degli handlers per i Container lifecycle events](https://kubernetes.io/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/)
.
3.3 - Container Lifecycle Hooks
===============================
Questa pagina descrive come i Container gestiti con kubelet possono utilizzare il lifecycle hook framework dei Container per l'esecuzione di codice eseguito in corrispondenza di alcuni eventi durante il loro ciclo di vita.
Overview
--------
Analogamente a molti framework di linguaggi di programmazione che hanno degli hooks legati al ciclo di vita dei componenti, come ad esempio Angular, Kubernetes fornisce ai Container degli hook legati al loro ciclo di vita dei Container. Gli hook consentono ai Container di essere consapevoli degli eventi durante il loro ciclo di gestione ed eseguire del codice implementato in un handler quando il corrispondente hook viene eseguito.
Container hooks
---------------
Esistono due tipi di hook che vengono esposti ai Container:
`PostStart`
Questo hook viene eseguito successivamente alla creazione del container. Tuttavia, non vi è garanzia che questo hook venga eseguito prima dell'ENTRYPOINT del container. Non vengono passati parametri all'handler.
`PreStop`
Questo hook viene eseguito prima della terminazione di un container a causa di una richiesta API o di un evento di gestione, come ad esempio un fallimento delle sonde di liveness/startup, preemption, risorse contese e altro. Una chiamata all'hook di `PreStop` fallisce se il container è in stato terminated o completed e l'hook deve finire prima che possa essere inviato il segnale di TERM per fermare il container. Il conto alla rovescia per la terminazione del Pod (grace period) inizia prima dell'esecuzione dell'hook `PreStop`, quindi indipendentemente dall'esito dell'handler, il container terminerà entro il grace period impostato. Non vengono passati parametri all'handler.
Una descrizione più dettagliata riguardante al processo di terminazione dei Pod può essere trovata in [Terminazione dei Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination)
.
### Implementazione degli hook handler
I Container possono accedere a un hook implementando e registrando un handler per tale hook. Ci sono due tipi di handler che possono essere implementati per i Container:
* Exec - Esegue un comando specifico, tipo `pre-stop.sh`, all'interno dei cgroup e namespace del Container. Le risorse consumate dal comando vengono contate sul Container.
* HTTP - Esegue una richiesta HTTP verso un endpoint specifico del Container.
### Esecuzione dell'hook handler
Quando viene richiamato l'hook legato al lifecycle del Container, il sistema di gestione di Kubernetes esegue l'handler secondo l'azione dell'hook, `httpGet` e `tcpSocket` vengono eseguiti dal processo kubelet, mentre `exec` è eseguito nel Container.
Le chiamate agli handler degli hook sono sincrone rispetto al contesto del Pod che contiene il Container. Questo significa che per un hook `PostStart`, l'ENTRYPOINT e l'hook si attivano in modo asincrono. Tuttavia, se l'hook impiega troppo tempo per essere eseguito o si blocca, il container non può raggiungere lo stato di `running`.
Gli hook di `PreStop` non vengono eseguiti in modo asincrono dall'evento di stop del container; l'hook deve completare la sua esecuzione prima che l'evento TERM possa essere inviato. Se un hook di `PreStop` si blocca durante la sua esecuzione, la fase del Pod rimarrà `Terminating` finchè il Pod non sarà rimosso forzatamente dopo la scadenza del suo `terminationGracePeriodSeconds`. Questo grace period si applica al tempo totale necessario per effettuare sia l'esecuzione dell'hook di `PreStop` che per l'arresto normale del container. Se, per esempio, il `terminationGracePeriodSeconds` è di 60, e l'hook impiega 55 secondi per essere completato, e il container impiega 10 secondi per fermarsi normalmente dopo aver ricevuto il segnale, allora il container verrà terminato prima di poter completare il suo arresto, poiché `terminationGracePeriodSeconds` è inferiore al tempo totale (55+10) necessario perché queste due cose accadano.
Se un hook `PostStart` o `PreStop` fallisce, allora il container viene terminato.
Gli utenti dovrebbero mantenere i loro handler degli hook i più leggeri possibili. Ci sono casi, tuttavia, in cui i comandi di lunga durata hanno senso, come il salvataggio dello stato del container prima della sua fine.
### Garanzia della chiamata dell'hook
La chiamata degli hook avviene _almeno una volta_, il che significa che un hook può essere chiamato più volte da un dato evento, come per `PostStart` o `PreStop`. Sta all'implementazione dell'hook gestire correttamente questo aspetto.
Generalmente, vengono effettuate singole chiamate agli hook. Se, per esempio, la destinazione di hook HTTP non è momentaneamente in grado di ricevere traffico, non c'è alcun tentativo di re invio. In alcuni rari casi, tuttavia, può verificarsi una doppia chiamata. Per esempio, se un kubelet si riavvia nel mentre dell'invio di un hook, questo potrebbe essere chiamato per una seconda volta dopo che il kubelet è tornato in funzione.
### Debugging Hook handlers
I log di un handler di hook non sono esposti negli eventi del Pod. Se un handler fallisce per qualche ragione, trasmette un evento. Per il `PostStart`, questo è l'evento di `FailedPostStartHook`, e per il `PreStop`, questo è l'evento di `FailedPreStopHook`. Puoi vedere questi eventi eseguendo `kubectl describe pod `. Ecco alcuni esempi di output di eventi dall'esecuzione di questo comando:
Events:
FirstSeen LastSeen Count From SubObjectPath Type Reason Message
--------- -------- ----- ---- ------------- -------- ------ -------
1m 1m 1 {default-scheduler } Normal Scheduled Successfully assigned test-1730497541-cq1d2 to gke-test-cluster-default-pool-a07e5d30-siqd
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulling pulling image "test:1.0"
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Created Created container with docker id 5c6a256a2567; Security:[seccomp=unconfined]
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulled Successfully pulled image "test:1.0"
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Started Started container with docker id 5c6a256a2567
38s 38s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 5c6a256a2567: PostStart handler: Error executing in Docker Container: 1
37s 37s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 8df9fdfd7054: PostStart handler: Error executing in Docker Container: 1
38s 37s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} Warning FailedSync Error syncing pod, skipping: failed to "StartContainer" for "main" with RunContainerError: "PostStart handler: Error executing in Docker Container: 1"
1m 22s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Warning FailedPostStartHook
Voci correlate
--------------
* Approfondisci [Container environment](https://kubernetes.io/it/docs/concepts/containers/container-environment/)
.
* Esegui un tutorial su come [definire degli handlers per i Container lifecycle events](https://kubernetes.io/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/)
.
4 - Configurazione
==================
Risorse che fornisce Kubernetes per configurare i Pods.
4.1 - ConfigMaps
================
La ConfigMap è un oggetto API usato per memorizzare dati non riservati in coppie chiave-valore. I [Pods](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
possono utilizzare le ConfigMaps come variabili d'ambiente, argomenti da riga di comando, o come files di configurazione all'interno di un [Volume](https://kubernetes.io/it/docs/concepts/storage/volumes/ "Una cartella contenente dati, accessibile dai containers all'interno del pod.")
.
La ConfigMap ti permette di disaccoppiare le configurazioni specifiche per ambiente dalle [immagini del container](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-image "Istanza archiviata di un cointainer che contiene un insieme di software e librerie necessarie per eseguire l'applicazione.")
, cosicchè le tue applicazioni siano facilmente portabili.
#### Attenzione:
La ConfigMap non fornisce riservatezza o cifratura dei dati. Se i dati che vuoi salvare sono confidenziali, usa un [Secret](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-secret "Contiene informazioni sensibili, come passwords, token OAuth, e chiavi ssh.")
piuttosto che una ConfigMap, o usa uno strumento di terze parti per tenere privati i tuoi dati.
Utilizzo
--------
Usa una ConfigMap per tenere separati i dati di configurazione dal codice applicativo.
Per esempio, immagina che stai sviluppando un'applicazione che puoi eseguire sul tuo computer (per lo sviluppo) e sul cloud (per gestire il traffico reale). Puoi scrivere il codice puntando a una variabile d'ambiente chiamata `DATABASE_HOST`. Localmente, puoi settare quella variabile a `localhost`. Nel cloud, la puoi settare referenziando il [Service](https://kubernetes.io/it/docs/concepts/services-networking/service/ "A way to expose an application running on a set of Pods as a network service.")
di Kubernetes che espone la componente del database sul tuo cluster. Ciò ti permette di andare a recuperare l'immagine del container eseguita nel cloud e fare il debug dello stesso codice localmente se necessario.
La ConfigMap non è pensata per sostenere una gran mole di dati. I dati memorizzati su una ConfigMap non possono superare 1 MiB. Se hai bisogno di memorizzare delle configurazioni che superano questo limite, puoi considerare di montare un volume oppure usare un database o un file service separato.
Oggetto ConfigMap
-----------------
La ConfigMap è un [oggetto](https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/)
API che ti permette di salvare configurazioni per poi poter essere riutilizzate da altri oggetti. A differenza di molti oggetti di Kubernetes che hanno una `spec`, la ConfigMap ha i campi `data` e `binaryData`. Questi campi accettano le coppie chiave-valore come valori. Entrambi i campi `data` e `binaryData` sono opzionali. Il campo `data` è pensato per contenere le stringhe UTF-8 mentre il campo `binaryData` è pensato per contenere dati binari come le stringhe codificate in base64.
Il nome di una ConfigMap deve essere un nome valido per un sottodominio DNS.
Ogni chiave sotto il campo `data` o `binaryData` deve consistere di caratteri alfanumerici, `-`, `_` o `.`. Le chiavi salvate sotto `data` non devono coincidere con le chiavi nel campo `binaryData`.
Partendo dalla versione 1.19, puoi aggiungere il campo `immutable` alla definizione di ConfigMap per creare una [ConfigMap immutabile](https://kubernetes.io/it/docs/concepts/_print/#configmap-immutable)
.
ConfigMaps e Pods
-----------------
Puoi scrivere una `spec` del Pod che si riferisce a una ConfigMap e configurare il o i containers in quel Pod sulla base dei dati presenti nella ConfigMap. Il Pod e la ConfigMap devono essere nello stesso Namespace.
#### Nota:
La `spec` di un [Pod statico](https://kubernetes.io/it/docs/tasks/configure-pod-container/static-pod/ "A pod managed directly by the kubelet daemon on a specific node.")
non può riferirsi a una ConfigMap o ad altri oggetti API.
Questo è un esempio di una ConfigMap che ha alcune chiavi con valori semplici, e altre chiavi dove il valore ha il formato di un frammento di configurazione.
apiVersion: v1
kind: ConfigMap
metadata:
name: game-demo
data:
# chiavi simili a proprietà; ogni chiave mappa un valore semplice
player_initial_lives: "3"
ui_properties_file_name: "user-interface.properties"
# chiavi simili a files
game.properties: |
enemy.types=aliens,monsters
player.maximum-lives=5
user-interface.properties: |
color.good=purple
color.bad=yellow
allow.textmode=true
Ci sono quattro modi differenti con cui puoi usare una ConfigMap per configurare un container all'interno di un Pod:
1. Argomento da riga di comando come entrypoint di un container
2. Variabile d'ambiente di un container
3. Aggiungere un file in un volume di sola lettura, per fare in modo che l'applicazione lo legga
4. Scrivere il codice da eseguire all'interno del Pod che utilizza l'API di Kubernetes per leggere la ConfigMap
Questi metodologie differenti permettono di utilizzare diversi metodi per modellare i dati che saranno consumati. Per i primi tre metodi, il [kubelet](https://kubernetes.io/it/docs/reference/generated/kubelet "Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.")
utilizza i dati della ConfigMap quando lancia il container (o più) in un Pod.
Per il quarto metodo dovrai scrivere il codice per leggere la ConfigMap e i suoi dati. Comunque, poiché stai utilizzando l'API di Kubernetes direttamente, la tua applicazione può sottoscriversi per ottenere aggiornamenti ogniqualvolta la ConfigMap cambia, e reagire quando ciò accade. Accedendo direttamente all'API di Kubernetes, questa tecnica ti permette anche di accedere a una ConfigMap in namespace differenti.
Ecco un esempio di Pod che usa i valori da `game-demo` per configurare il container:
apiVersion: v1
kind: Pod
metadata:
name: configmap-demo-pod
spec:
containers:
- name: demo
image: alpine
command: ["sleep", "3600"]
env:
# Definire la variabile d'ambiente
- name: PLAYER_INITIAL_LIVES # Notare che il case qui è differente
# dal nome della key nella ConfigMap.
valueFrom:
configMapKeyRef:
name: game-demo # La ConfigMap da cui proviene il valore.
key: player_initial_lives # La chiave da recuperare.
- name: UI_PROPERTIES_FILE_NAME
valueFrom:
configMapKeyRef:
name: game-demo
key: ui_properties_file_name
volumeMounts:
- name: config
mountPath: "/config"
readOnly: true
volumes:
# Settare i volumi al livello del Pod, in seguito montarli nei containers all'interno del Pod
- name: config
configMap:
# Fornire il nome della ConfigMap che vuoi montare.
name: game-demo
# Una lista di chiavi dalla ConfigMap per essere creata come file
items:
- key: "game.properties"
path: "game.properties"
- key: "user-interface.properties"
path: "user-interface.properties"
Una ConfigMap non differenzia tra le proprietà di una singola linea e un file con più linee e valori. L'importante è il modo in cui i Pods e gli altri oggetti consumano questi valori.
Per questo esempio, definire un volume e montarlo all'interno del container `demo` come `/config` crea due files, `/config/game.properties` e `/config/user-interface.properties`, sebbene ci siano quattro chiavi nella ConfigMap. Ciò avviene perché la definizione del Pod specifica una lista di `items` nella sezione dei `volumes`. Se ometti del tutto la lista degli `items`, ogni chiave nella ConfigMap diventerà un file con lo stesso nome della chiave, e otterrai 4 files.
Usare le ConfigMaps
-------------------
Le ConfigMaps possono essere montate come volumi. Le ConfigMaps possono anche essere utilizzate da altre parti del sistema, senza essere direttamente esposte al Pod. Per esempio, le ConfigMaps possono contenere l'informazione che altre parti del sistema utilizzeranno per la loro configurazione.
La maniera più comune per usare le ConfigMaps è di configurare i containers che sono in esecuzione in un Pod nello stesso namespace. Puoi anche utilizzare una ConfigMap separatamente.
Per esempio, potresti incontrare [addons](https://kubernetes.io/it/docs/concepts/cluster-administration/addons/ "Resources that extend the functionality of Kubernetes.")
o [operators](https://kubernetes.io/it/docs/concepts/extend-kubernetes/operator/ "A specialized controller used to manage a custom resource")
che adattano il loro comportamento in base a una ConfigMap.
### Usare le ConfigMaps come files in un Pod
Per utilizzare una ConfigMap in un volume all'interno di un Pod:
1. Creare una ConfigMap o usarne una che già esiste. Più Pods possono utilizzare la stessa ConfigMap.
2. Modificare la definizione del Pod per aggiungere un volume sotto `.spec.volumes[]`. Nominare il volume in qualsiasi modo, e avere un campo `.spec.volumes[].configMap.name` configurato per referenziare il tuo oggetto ConfigMap.
3. Aggiungere un `.spec.containers[].volumeMounts[]` a ogni container che necessiti di una ConfigMap. Nello specifico `.spec.containers[].volumeMounts[].readOnly = true` e `.spec.containers[].volumeMounts[].mountPath` in una cartella inutilizzata dove vorresti che apparisse la ConfigMap.
4. Modificare l'immagine o il comando utilizzato così che il programma cerchi i files in quella cartella. Ogni chiave nella sezione `data` della ConfigMap si converte in un file sotto `mountPath`.
Questo è un esempio di un Pod che monta una ConfigMap in un volume:
apiVersion: v1
kind: Pod
metadata:
name: mypod
spec:
containers:
- name: mypod
image: redis
volumeMounts:
- name: foo
mountPath: "/etc/foo"
readOnly: true
volumes:
- name: foo
configMap:
name: myconfigmap
Ogni ConfigMap che desideri utilizzare deve essere referenziata in `.spec.volumes`.
Se c'è più di un container nel Pod, allora ogni container necessita del suo blocco `volumeMounts`, ma solamente un `.spec.volumes` è necessario ConfigMap.
#### Le ConfigMaps montate sono aggiornate automaticamente
Quando una ConfigMap è utilizzata in un volume ed è aggiornata, anche le chiavi vengono aggiornate. Il kubelet controlla se la ConfigMap montata è aggiornata ad ogni periodo di sincronizzazione. Ad ogni modo, il kubelet usa la sua cache locale per ottenere il valore attuale della ConfigMap. Il tipo di cache è configurabile usando il campo `ConfigMapAndSecretChangeDetectionStrategy` nel [KubeletConfiguration struct](https://kubernetes.io/docs/reference/config-api/kubelet-config.v1beta1/)
. Una ConfigMap può essere propagata per vista (default), ttl-based, o redirigendo tutte le richieste direttamente all'API server. Come risultato, il ritardo totale dal momento in cui la ConfigMap è aggiornata al momento in cui nuove chiavi sono propagate al Pod può essere tanto lungo quanto il periodo della sincronizzazione del kubelet + il ritardo della propagazione della cache, dove il ritardo della propagazione della cache dipende dal tipo di cache scelta (è uguale rispettivamente al ritardo della propagazione, ttl della cache, o zero).
Le ConfigMaps consumate come variabili d'ambiente non sono aggiornate automaticamente e necessitano di un riavvio del pod.
#### Nota:
Un container utilizzando una ConfigMap come un [subPath](https://kubernetes.io/docs/concepts/storage/volumes#using-subpath)
volume mount non riceverà gli aggiornamenti della ConfigMap.
ConfigMaps Immutabili
---------------------
FEATURE STATE: `Kubernetes v1.21 [stable]`
La funzionalità di Kubernetes _Immutable Secrets and ConfigMaps_ fornisce un'opzione per configurare Secrets individuali e ConfigMaps come immutabili. Per clusters che usano le ConfigMaps come estensione (almeno decine o centinaia di ConfigMap uniche montate nel Pod), prevenire i cambiamenti nei loro dati ha i seguenti vantaggi:
* protezione da aggiornamenti accidentali (o non voluti) che potrebbero causare l'interruzione di applicazioni
* miglioramento della performance del tuo cluster riducendo significativamente il carico sul kube-apiserver, chiudendo l'ascolto sulle ConfigMaps che sono segnate come immutabili.
Questa funzionalità è controllata dal `ImmutableEphemeralVolumes` [feature gate](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/)
. Puoi creare una ConfigMap immutabile settando il campo `immutable` a `true`. Per esempio:
apiVersion: v1
kind: ConfigMap
metadata:
...
data:
...
immutable: true
Una volta che una ConfigMap è segnata come immutabile, _non_ è possibile invertire questo cambiamento né cambiare il contenuto del campo `data` o `binaryData` field. Puoi solamente cancellare e ricreare la ConfigMap. Poiché i Pods hanno un puntamento verso la ConfigMap eliminata, è raccomandato di ricreare quei Pods.
Voci correlate
--------------
* Leggi in merito [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)
.
* Leggi [Configura un Pod per utilizzare una ConfigMap](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/)
.
* Leggi in merito [Modificare una ConfigMap (o qualsiasi altro oggetto di Kubernetes)](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/update-api-object-kubectl-patch/)
* Leggi [The Twelve-Factor App](https://12factor.net/)
per comprendere il motivo di separare il codice dalla configurazione.
5 - Amministrazione del Cluster
===============================
5.1 - Proxy in Kubernetes
=========================
Questa pagina spiega i proxy utilizzati con Kubernetes.
Proxy
-----
Esistono diversi proxy che puoi incontrare quando usi Kubernetes:
1. Il [kubectl proxy](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#direct-accessing-the-rest-api)
:
- viene eseguito sul computer di un utente o in un pod - collega un localhost address all'apiserver di Kubernetes - il client comunica con il proxy in HTTP - il proxy comunica con l'apiserver in HTTPS - individua l'apiserver - aggiunge gli header di autenticazione
1. L'[apiserver proxy](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster-services/#discovering-builtin-services)
:
- è un proxy presente nell'apiserver - collega un utente al di fuori del cluster agli IP del cluster che altrimenti potrebbero non essere raggiungibili - è uno dei processi dell'apiserver - il client comunica con il proxy in HTTPS (o HTTP se l'apiserver è configurato in tal modo) - il proxy comunica con il target via HTTP o HTTPS come scelto dal proxy utilizzando le informazioni disponibili - può essere utilizzato per raggiungere un nodo, un pod o un servizio - esegue il bilanciamento del carico quando viene utilizzato per raggiungere un servizio
1. Il [kube proxy](https://kubernetes.io/docs/concepts/services-networking/service/#ips-and-vips)
:
- è eseguito su ciascun nodo - fa da proxy per comunicazioni UDP, TCP e SCTP - non gestisce il protocollo HTTP - esegue il bilanciamento del carico - è usato solo per raggiungere i servizi
1. Un proxy/bilanciatore di carico di fronte agli apiserver:
- la sua esistenza e implementazione variano da cluster a cluster (ad esempio nginx) - si trova tra i client e uno o più apiserver - funge da bilanciatore di carico se ci sono più di un apiserver.
1. Cloud Load Balancer su servizi esterni:
- sono forniti da alcuni fornitori di servizi cloud (ad es. AWS ELB, Google Cloud Load Balancer) - vengono creati automaticamente quando il servizio Kubernetes ha tipo `LoadBalancer` - solitamente supporta solo UDP / TCP - il supporto SCTP dipende dall'implementazione del bilanciatore di carico del provider cloud - l'implementazione varia a seconda del provider cloud.
Gli utenti di Kubernetes in genere non devono preoccuparsi alcun proxy, se non i primi due tipi. L'amministratore del cluster in genere assicurerà che gli altri tipi di proxy siano impostati correttamente.
Richiedere reindirizzamenti
---------------------------
I proxy hanno sostituito le funzioni di reindirizzamento. I reindirizzamenti sono stati deprecati.
6 - Esempio di modello di concetto
==================================
#### Nota:
Assicurati anche di [creare una voce nel sommario](https://kubernetes.io/docs/home/contribute/write-new-topic/#creating-an-entry-in-the-table-of-contents)
per il tuo nuovo documento.
Questa pagina spiega ...
Comprendendo ...
----------------
Kubernetes fornisce ...
Usando ...
----------
Usare
Voci correlate
--------------
**\[Sezione opzionale\]**
* Ulteriori informazioni su [Scrivere un nuovo argomento](https://kubernetes.io/docs/home/contribuisci/scrivi-nuovo-argomento/)
.
* Vedi [Uso dei modelli di pagina - Modello di concetto](https://kubernetes.io/docs/home/contribuis/page-templates/#concept_template)
su come utilizzare questo modello.
---
# Przechowywanie danych | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/concepts/storage/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/concepts/storage/)
.
Przechowywanie danych
=====================
Trwałe i tymczasowe mechanizmy przechowywania danych dla Podów w klastrze.
---
# Kubernetes Documentation | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/docs/home/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/docs/home/)
.
Kubernetes Documentation
========================
Kubernetes is an open source container orchestration engine for automating deployment, scaling, and management of containerized applications. The open source project is hosted by the Cloud Native Computing Foundation.
* 1: [Available Documentation Versions](https://kubernetes.io/docs/home/_print/#pg-92dfff0ca612d0bff40171aa9df6c4ae)
1 - Available Documentation Versions
====================================
This website contains documentation for the current version of Kubernetes and the four previous versions of Kubernetes.
The availability of documentation for a Kubernetes version is separate from whether that release is currently supported. Read [Support period](https://kubernetes.io/releases/patch-releases/#support-period)
to learn about which versions of Kubernetes are officially supported, and for how long.
---
# कुबेरनेट्स प्रलेखन | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/home/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/home/)
.
कुबेरनेट्स प्रलेखन
==================
कुबेरनेट्स कंटेनरीकृत एप्लीकेशन के परिनियोजन, स्केलिंग और प्रबंधन को स्वचालित करने के लिए एक ओपन सोर्स कंटेनर ऑर्केस्ट्रेशन इंजन है| यह ओपन सोर्स प्रोजेक्ट Cloud Native Computing Foundation द्वारा होस्ट किया गया है।
* 1: [प्रलेखन के उपलब्ध संस्करण](https://kubernetes.io/hi/docs/home/_print/#pg-92dfff0ca612d0bff40171aa9df6c4ae)
1 - प्रलेखन के उपलब्ध संस्करण
=============================
इस वेबसाइट में कुबेरनेट्स के वर्तमान और चार पिछले संस्करण के प्रलेखन शामिल हैं।
---
# Kubernetes Dokumentation | Kubernetes
Das ist eine für den Ausdruck optimierte Ansicht des gesamten Kapitels inkl. Unterseiten. [Druckvorgang starten](https://kubernetes.io/de/docs/home/_print/#)
.
[Zur Standardansicht zurückkehren](https://kubernetes.io/de/docs/home/)
.
Kubernetes Dokumentation
========================
* 1: [Unterstützte Versionen der Kubernetes-Dokumentation](https://kubernetes.io/de/docs/home/_print/#pg-92dfff0ca612d0bff40171aa9df6c4ae)
1 - Unterstützte Versionen der Kubernetes-Dokumentation
=======================================================
Diese Website enthält Dokumentation für die aktuelle Version von Kubernetes und die vier vorherigen Versionen von Kubernetes.
---
# उत्तम प्रथाएं | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/setup/best-practices/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/setup/best-practices/)
.
उत्तम प्रथाएं
=============
---
# Administrasi Klaster | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/id/docs/concepts/cluster-administration/)
.
Administrasi Klaster
====================
* 1: [Ikhtisar Administrasi Klaster](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-fb494ea3b1874bd753dcd11c3f35c2dc)
* 2: [Sertifikat](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-2bf9a93ab5ba014fb6ff70b22c29d432)
* 3: [Penyedia Layanan Cloud](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-d0e81230313a2684e7b7e40b21834e30)
* 4: [Mengelola Resource](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-3aeeecf7cdb2a21eb4b31db7a71c81e2)
* 5: [Jaringan Klaster](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-d649067a69d8d5c7e71564b42b96909e)
* 6: [Arsitektur Logging](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-c4b1e87a84441f8a90699a345ce48d68)
* 7: [Metrik untuk Komponen Sistem Kubernetes](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-cbfd3654996eae9fcdef009f70fa83f0)
* 8: [Konfigurasi Garbage Collection pada kubelet](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-2e05a56491965ae320c2662590b2ca18)
* 9: [Berbagai Proxy di Kubernetes](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-08e94e6a480e0d6b2de72d84a1b97617)
* 10: [Metrik controller manager](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-d5cc46b61677b53f61a407d20bdd0830)
* 11: [Instalasi Add-ons](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-85d633ae590aa20ec024f1b7af1d74fc)
* 12: [Prioritas dan Kesetaraan API (API Priority and Fairness)](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#pg-31c9327d2332c585341b64ddafa19cdd)
1 - Ikhtisar Administrasi Klaster
=================================
Ikhtisar administrasi klaster ini ditujukan untuk siapapun yang akan membuat atau mengelola klaster Kubernetes. Diharapkan untuk memahami beberapa [konsep](https://kubernetes.io/id/docs/concepts/)
dasar Kubernetes sebelumnya.
Perencanaan Klaster
-------------------
Lihat panduan di [Persiapan](https://kubernetes.io/id/docs/setup/)
untuk mempelajari beberapa contoh tentang bagaimana merencanakan, mengatur dan mengonfigurasi klaster Kubernetes. Solusi yang akan dipaparkan di bawah ini disebut _distro_.
Sebelum memilih panduan, berikut adalah beberapa hal yang perlu dipertimbangkan:
* Apakah kamu hanya ingin mencoba Kubernetes pada komputermu, atau kamu ingin membuat sebuah klaster dengan _high-availability_, _multi-node_? Pilihlah distro yang paling sesuai dengan kebutuhanmu.
* **Jika kamu merencanakan klaster dengan _high-availability_**, pelajari bagaimana cara mengonfigurasi [klaster pada _multiple zone_](https://kubernetes.io/id/docs/concepts/cluster-administration/federation/)
.
* Apakah kamu akan menggunakan **Kubernetes klaster di _hosting_**, seperti [Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine/)
, atau **_hosting_ sendiri klastermu**?
* Apakah klastermu berada pada **_on-premises_**, atau **di cloud (IaaS)**? Kubernetes belum mendukung secara langsung klaster hibrid. Sebagai gantinya, kamu dapat membuat beberapa klaster.
* **Jika kamu ingin mengonfigurasi Kubernetes _on-premises_**, pertimbangkan [model jaringan](https://kubernetes.io/id/docs/concepts/cluster-administration/networking/)
yang paling sesuai.
* Apakah kamu ingin menjalankan Kubernetes pada **"bare metal" _hardware_** atau pada **_virtual machines_ (VM)**?
* Apakah kamu **hanya ingin mencoba klaster Kubernetes**, atau kamu ingin ikut aktif melakukan **pengembangan kode dari proyek Kubernetes**? Jika jawabannya yang terakhir, pilihlah distro yang aktif dikembangkan. Beberapa distro hanya menggunakan rilis _binary_, namun menawarkan lebih banyak variasi pilihan.
* Pastikan kamu paham dan terbiasa dengan beberapa [komponen](https://kubernetes.io/docs/admin/cluster-components/)
yang dibutuhkan untuk menjalankan sebuah klaster.
Catatan: Tidak semua distro aktif dikelola. Pilihlah distro yang telah diuji dengan versi terkini dari Kubernetes.
Mengelola Klaster
-----------------
* [Mengelola klaster](https://kubernetes.io/docs/tasks/administer-cluster/cluster-management/)
akan menjabarkan beberapa topik terkait _lifecycle_ dari klaster: membuat klaster baru, melakukan _upgrade_ pada _node master_ dan _worker_, melakukan pemeliharaan _node_ (contoh: _upgrade_ kernel), dan melakukan _upgrade_ versi Kubernetes API pada klaster yang sedang berjalan.
* Pelajari bagaimana cara [mengatur _node_](https://kubernetes.io/docs/concepts/nodes/node/)
.
* Pelajari bagaimana cara membuat dan mengatur kuota resource [(_resource quota_)](https://kubernetes.io/id/docs/concepts/policy/resource-quotas/)
untuk _shared_ klaster.
Mengamankan Klaster
-------------------
* [Sertifikat (_certificate_)](https://kubernetes.io/id/docs/concepts/cluster-administration/certificates/)
akan menjabarkan langkah-langkah untuk membuat sertifikat menggunakan beberapa _tool chains_.
* [Kubernetes _Container Environment_](https://kubernetes.io/id/docs/concepts/containers/container-environment-variables/)
akan menjelaskan _environment_ untuk kontainer yang dikelola oleh Kubelet pada Kubernetes _node_.
* [Mengontrol Akses ke Kubernetes API](https://kubernetes.io/docs/reference/access-authn-authz/controlling-access/)
akan menjabarkan bagaimana cara mengatur izin (_permission_) untuk akun pengguna dan _service account_.
* [Autentikasi](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)
akan menjelaskan autentikasi di Kubernetes, termasuk ragam pilihan autentikasi.
* [Otorisasi](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)
dibedakan dari autentikasi, digunakan untuk mengontrol bagaimana _HTTP call_ ditangani.
* [Menggunakan _Admission Controllers_](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)
akan menjelaskan _plug-in_ yang akan melakukan intersep permintaan sebelum menuju ke server Kubernetes API, setelah autentikasi dan otorisasi dilakukan.
* [Menggunakan Sysctls pada Klaster Kubernetes](https://kubernetes.io/docs/concepts/cluster-administration/sysctl-cluster/)
akan menjabarkan tentang cara menggunakan perintah `sysctl` pada _command-line_ untuk mengatur parameter kernel.
* [Audit](https://kubernetes.io/docs/tasks/debug-application-cluster/audit/)
akan menjelaskan bagaimana cara berinteraksi dengan log audit Kubernetes.
### Mengamankan Kubelet
* [Komunikasi Master-Node](https://kubernetes.io/docs/concepts/architecture/master-node-communication/)
* [TLS _bootstrapping_](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet-tls-bootstrapping/)
* [Autentikasi/Otorisasi Kubelet](https://kubernetes.io/docs/admin/kubelet-authentication-authorization/)
Layanan Tambahan Klaster
------------------------
* [Integrasi DNS](https://kubernetes.io/id/docs/concepts/services-networking/dns-pod-service/)
akan menjelaskan bagaimana cara _resolve_ suatu nama DNS langsung pada _service_ Kubernetes.
* [_Logging_ dan _Monitoring_ Aktivitas Klaster](https://kubernetes.io/id/docs/concepts/cluster-administration/logging/)
akan menjelaskan bagaimana cara _logging_ bekerja di Kubernetes serta bagaimana cara mengimplementasikannya.
2 - Sertifikat
==============
Saat menggunakan autentikasi sertifikat klien, kamu dapat membuat sertifikat secara manual melalui `easyrsa`, `openssl` atau `cfssl`.
### easyrsa
**easyrsa** dapat digunakan untuk menghasilkan sertifikat klaster kamu secara manual.
1. Unduh, buka paket, dan inisialisasi versi tambal easyrsa3.
curl -LO https://dl.k8s.io/easy-rsa/easy-rsa.tar.gz
tar xzf easy-rsa.tar.gz
cd easy-rsa-master/easyrsa3
./easyrsa init-pki
2. Hasilkan CA. (`--batch` untuk atur mode otomatis. `--req-cn` untuk menggunakan _default_ CN.)
./easyrsa --batch "--req-cn=${MASTER_IP}@`date +%s`" build-ca nopass
3. Hasilkan sertifikat dan kunci _server_. Argumen `--subject-alt-name` digunakan untuk mengatur alamat IP dan nama DNS yang dapat diakses oleh _server_ API. `MASTER_CLUSTER_IP` biasanya merupakan IP pertama dari CIDR _service cluster_ yang diset dengan argumen `--service-cluster-ip-range` untuk _server_ API dan komponen manajer pengontrol. Argumen `--days` digunakan untuk mengatur jumlah hari masa berlaku sertifikat. Sampel di bawah ini juga mengasumsikan bahwa kamu menggunakan `cluster.local` sebagai nama _domain_ DNS _default_.
./easyrsa --subject-alt-name="IP:${MASTER_IP},"\
"IP:${MASTER_CLUSTER_IP},"\
"DNS:kubernetes,"\
"DNS:kubernetes.default,"\
"DNS:kubernetes.default.svc,"\
"DNS:kubernetes.default.svc.cluster,"\
"DNS:kubernetes.default.svc.cluster.local" \
--days=10000 \
build-server-full server nopass
4. Salin `pki/ca.crt`, `pki/issued/server.crt`, dan `pki/private/server.key` ke direktori kamu.
5. Isi dan tambahkan parameter berikut ke dalam parameter mulai _server_ API:
--client-ca-file=/yourdirectory/ca.crt
--tls-cert-file=/yourdirectory/server.crt
--tls-private-key-file=/yourdirectory/server.key
### openssl
**openssl** secara manual dapat menghasilkan sertifikat untuk klaster kamu.
1. Hasilkan ca.key dengan 2048bit:
openssl genrsa -out ca.key 2048
2. Hasilkan ca.crt berdasarkan ca.key (gunakan -days untuk mengatur waktu efektif sertifikat):
openssl req -x509 -new -nodes -key ca.key -subj "/CN=${MASTER_IP}" -days 10000 -out ca.crt
3. Hasilkan server.key dengan 2048bit:
openssl genrsa -out server.key 2048
4. Buat _file_ konfigurasi untuk menghasilkan _Certificate Signing Request_ (CSR). Pastikan untuk mengganti nilai yang ditandai dengan kurung sudut (mis. ``) dengan nilai sebenarnya sebelum menyimpan ke _file_ (mis. `csr.conf`). Perhatikan bahwa nilai `MASTER_CLUSTER_IP` adalah layanan IP klaster untuk _server_ API seperti yang dijelaskan dalam subbagian sebelumnya. Sampel di bawah ini juga mengasumsikan bahwa kamu menggunakan `cluster.local` sebagai nama _domain_ DNS _default_.
[ req ]
default_bits = 2048
prompt = no
default_md = sha256
req_extensions = req_ext
distinguished_name = dn
[ dn ]
C =
ST =
L =
O =
OU =
CN =
[ req_ext ]
subjectAltName = @alt_names
[ alt_names ]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster
DNS.5 = kubernetes.default.svc.cluster.local
IP.1 =
IP.2 =
[ v3_ext ]
authorityKeyIdentifier=keyid,issuer:always
basicConstraints=CA:FALSE
keyUsage=keyEncipherment,dataEncipherment
extendedKeyUsage=serverAuth,clientAuth
subjectAltName=@alt_names
5. Hasilkan permintaan penandatanganan sertifikat berdasarkan _file_ konfigurasi:
openssl req -new -key server.key -out server.csr -config csr.conf
6. Hasilkan sertifikat _server_ menggunakan ca.key, ca.crt dan server.csr:
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
-CAcreateserial -out server.crt -days 10000 \
-extensions v3_ext -extfile csr.conf -sha256
7. Lihat sertifikat:
openssl x509 -noout -text -in ./server.crt
Terakhir, tambahkan parameter yang sama ke dalam parameter mulai _server_ API.
### cfssl
**cfssl** adalah alat lain untuk pembuatan sertifikat.
1. Unduh, buka paket dan siapkan _command line tools_ seperti yang ditunjukkan di bawah ini. Perhatikan bahwa kamu mungkin perlu menyesuaikan contoh perintah berdasarkan arsitektur perangkat keras dan versi cfssl yang kamu gunakan.
curl -L https://pkg.cfssl.org/R1.2/cfssl_linux-amd64 -o cfssl
chmod +x cfssl
curl -L https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64 -o cfssljson
chmod +x cfssljson
curl -L https://pkg.cfssl.org/R1.2/cfssl-certinfo_linux-amd64 -o cfssl-certinfo
chmod +x cfssl-certinfo
2. Buat direktori untuk menyimpan _artifacts_ dan inisialisasi cfssl:
mkdir cert
cd cert
../cfssl print-defaults config > config.json
../cfssl print-defaults csr > csr.json
3. Buat _file_ konfigurasi JSON untuk menghasilkan _file_ CA, misalnya, `ca-config.json`:
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"kubernetes": {
"usages": [\
"signing",\
"key encipherment",\
"server auth",\
"client auth"\
],
"expiry": "8760h"
}
}
}
}
4. Buat _file_ konfigurasi JSON untuk CA _certificate signing request_ (CSR), misalnya, `ca-csr.json`. Pastikan untuk mengganti nilai yang ditandai dengan kurung sudut dengan nilai sebenarnya yang ingin kamu gunakan.
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names":[{\
"C": "",\
"ST": "",\
"L": "",\
"O": "",\
"OU": ""\
}]
}
5. Hasilkan kunci CA (`ca-key.pem`) dan sertifikat (`ca.pem`):
../cfssl gencert -initca ca-csr.json | ../cfssljson -bare ca
6. Buat _file_ konfigurasi JSON untuk menghasilkan kunci dan sertifikat untuk API _server_, misalnya, `server-csr.json`. Pastikan untuk mengganti nilai dalam kurung sudut dengan nilai sebenarnya yang ingin kamu gunakan. `MASTER_CLUSTER_IP` adalah layanan klaster IP untuk _server_ API seperti yang dijelaskan dalam subbagian sebelumnya. Sampel di bawah ini juga mengasumsikan bahwa kamu menggunakan `cluster.local` sebagai nama _domain_ DNS _default_.
{
"CN": "kubernetes",
"hosts": [\
"127.0.0.1",\
"",\
"",\
"kubernetes",\
"kubernetes.default",\
"kubernetes.default.svc",\
"kubernetes.default.svc.cluster",\
"kubernetes.default.svc.cluster.local"\
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [{\
"C": "",\
"ST": "",\
"L": "",\
"O": "",\
"OU": ""\
}]
}
7. Buat kunci dan sertifikat untuk server API, yang mana awalnya di simpan masing-masing ke dalam _file_ `server-key.pem` dan `server.pem`:
../cfssl gencert -ca=ca.pem -ca-key=ca-key.pem \
--config=ca-config.json -profile=kubernetes \
server-csr.json | ../cfssljson -bare server
Distribusi Sertifikat _Self-Signed_ CA
--------------------------------------
_Node_ klien dapat menolak untuk mengakui sertifikat CA yang ditandatangani sendiri sebagai valid. Untuk _deployment_ non-produksi, atau untuk _deployment_ yang berjalan di belakang _firewall_ perusahaan, kamu dapat mendistribusikan sertifikat CA yang ditandatangani sendiri untuk semua klien dan _refresh_ daftar lokal untuk sertifikat yang valid.
Pada setiap klien, lakukan operasi berikut:
sudo cp ca.crt /usr/local/share/ca-certificates/kubernetes.crt
sudo update-ca-certificates
Updating certificates in /etc/ssl/certs...
1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d....
done.
Sertifikat API
--------------
Kamu dapat menggunakan API `Certificate.k8s.io` untuk menyediakan sertifikat x509 yang digunakan untuk autentikasi seperti yang didokumentasikan [di sini](https://kubernetes.io/id/docs/tasks/tls/managing-tls-in-a-cluster)
.
3 - Penyedia Layanan Cloud
==========================
Laman ini akan menjelaskan bagaimana cara mengelola Kubernetes yang berjalan pada penyedia layanan cloud tertentu.
### Kubeadm
[Kubeadm](https://kubernetes.io/id/docs/reference/setup-tools/kubeadm/)
merupakan salah satu cara yang banyak digunakan untuk membuat klaster Kubernetes. Kubeadm memiliki beragam opsi untuk mengatur konfigurasi spesifik untuk penyedia layanan cloud. Salah satu contoh yang biasa digunakan pada penyedia cloud _in-tree_ yang dapat diatur dengan kubeadm adalah sebagai berikut:
apiVersion: kubeadm.k8s.io/v1beta1
kind: InitConfiguration
nodeRegistration:
kubeletExtraArgs:
cloud-provider: "openstack"
cloud-config: "/etc/kubernetes/cloud.conf"
---
apiVersion: kubeadm.k8s.io/v1beta1
kind: ClusterConfiguration
kubernetesVersion: v1.13.0
apiServer:
extraArgs:
cloud-provider: "openstack"
cloud-config: "/etc/kubernetes/cloud.conf"
extraVolumes:
- name: cloud
hostPath: "/etc/kubernetes/cloud.conf"
mountPath: "/etc/kubernetes/cloud.conf"
controllerManager:
extraArgs:
cloud-provider: "openstack"
cloud-config: "/etc/kubernetes/cloud.conf"
extraVolumes:
- name: cloud
hostPath: "/etc/kubernetes/cloud.conf"
mountPath: "/etc/kubernetes/cloud.conf"
Penyedia layanan cloud _in-tree_ biasanya membutuhkan `--cloud-provider` dan `--cloud-config` yang ditentukan sebelumnya pada _command lines_ untuk [kube-apiserver](https://kubernetes.io/docs/admin/kube-apiserver/)
, [kube-controller-manager](https://kubernetes.io/docs/admin/kube-controller-manager/)
dan [kubelet](https://kubernetes.io/docs/admin/kubelet/)
. Konten dari _file_ yang ditentukan pada `--cloud-config` untuk setiap provider akan dijabarkan di bawah ini.
Untuk semua penyedia layanan cloud eksternal, silakan ikuti instruksi pada repositori masing-masing penyedia layanan.
AWS
---
Bagian ini akan menjelaskan semua konfigurasi yang dapat diatur saat menjalankan Kubernetes pada Amazon Web Services.
### Nama Node
Penyedia layanan cloud AWS menggunakan nama DNS privat dari _instance_ AWS sebagai nama dari objek Kubernetes Node.
### _Load Balancer_
Kamu dapat mengatur [load balancers eksternal](https://kubernetes.io/id/docs/tasks/access-application-cluster/create-external-load-balancer/)
sehingga dapat menggunakan fitur khusus AWS dengan mengatur anotasi seperti di bawah ini.
apiVersion: v1
kind: Service
metadata:
name: example
namespace: kube-system
labels:
run: example
annotations:
service.beta.kubernetes.io/aws-load-balancer-ssl-cert: arn:aws:acm:xx-xxxx-x:xxxxxxxxx:xxxxxxx/xxxxx-xxxx-xxxx-xxxx-xxxxxxxxx #ganti nilai ini
service.beta.kubernetes.io/aws-load-balancer-backend-protocol: http
spec:
type: LoadBalancer
ports:
- port: 443
targetPort: 5556
protocol: TCP
selector:
app: example
Pengaturan lainnya juga dapat diaplikasikan pada layanan _load balancer_ di AWS dengan menggunakan anotasi-anotasi. Berikut ini akan dijelaskan anotasi yang didukung oleh AWS ELB:
* `service.beta.kubernetes.io/aws-load-balancer-access-log-emit-interval`: Digunakan untuk menentukan interval pengeluaran log akses.
* `service.beta.kubernetes.io/aws-load-balancer-access-log-enabled`: Digunakan untuk mengaktifkan atau menonaktifkan log akses.
* `service.beta.kubernetes.io/aws-load-balancer-access-log-s3-bucket-name`: Digunakan untuk menentukan nama _bucket_ S3 log akses.
* `service.beta.kubernetes.io/aws-load-balancer-access-log-s3-bucket-prefix`: Digunakan untuk menentukan prefix _bucket_ S3 log akses.
* `service.beta.kubernetes.io/aws-load-balancer-additional-resource-tags`: Digunakan untuk menentukan daftar tag tambahan pada ELB dengan menggunakan parameter _key-value_. Contoh: `"Key1=Val1,Key2=Val2,KeyNoVal1=,KeyNoVal2"`.
* `service.beta.kubernetes.io/aws-load-balancer-backend-protocol`: Digunakan untuk menentukan protokol yang digunakan oleh _backend_ (pod) di belakang _listener_. Jika diset ke `http` (default) atau `https`, maka akan dibuat HTTPS _listener_ yang akan mengakhiri koneksi dan meneruskan _header_. Jika diset ke `ssl` atau `tcp`, maka akan digunakan "raw" SSL _listener_. Jika diset ke `http` dan `aws-load-balancer-ssl-cert` tidak digunakan, maka akan digunakan HTTP _listener_.
* `service.beta.kubernetes.io/aws-load-balancer-ssl-cert`: Digunakan untuk meminta _secure_ _listener_. Nilai yang dimasukkan adalah sertifikat ARN yang valid. Info lebih lanjut lihat [ELB Listener Config](http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elb-listener-config.html)
CertARN merupakan IAM atau CM certificate ARN, contoh: `arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012`.
* `service.beta.kubernetes.io/aws-load-balancer-connection-draining-enabled`: Digunakan untuk mengaktifkan atau menonaktfkan _connection draining_.
* `service.beta.kubernetes.io/aws-load-balancer-connection-draining-timeout`: Digunakan untuk menentukan _connection draining timeout_.
* `service.beta.kubernetes.io/aws-load-balancer-connection-idle-timeout`: Digunakan untuk menentukan _idle connection timeout_.
* `service.beta.kubernetes.io/aws-load-balancer-cross-zone-load-balancing-enabled`: Digunakan untuk mengaktifkan atau menonaktifkan _cross-zone load balancing_.
* `service.beta.kubernetes.io/aws-load-balancer-extra-security-groups`: Digunakan untuk menentukan grup keamanan yang akan ditambahkan pada ELB yang dibuat.
* `service.beta.kubernetes.io/aws-load-balancer-internal`: Digunakan sebagai indikasi untuk menggunakan internal ELB.
* `service.beta.kubernetes.io/aws-load-balancer-proxy-protocol`: Digunakan untuk mengaktifkan _proxy protocol_ pada ELB. Saat ini hanya dapat menerima nilai `*` yang berarti mengaktifkan _proxy protocol_ pada semua ELB _backends_. Di masa mendatang kamu juga dapat mengatur agar _proxy protocol_ hanya aktif pada _backends_ tertentu..
* `service.beta.kubernetes.io/aws-load-balancer-ssl-ports`: Digunakan untuk menentukan daftar port--yang dipisahkan koma-- yang akan menggunakan SSL/HTTPS _listeners_. Nilai _default_ yaitu `*` (semua).
Informasi anotasi untuk AWS di atas diperoleh dari komentar pada [aws.go](https://github.com/kubernetes/kubernetes/blob/master/pkg/cloudprovider/providers/aws/aws.go)
Azure
-----
### Nama Node
Penyedia layanan cloud Azure menggunakan _hostname_ dari _node_ (yang ditentukan oleh kubelet atau menggunakan `--hostname-override`) sebagai nama dari objek Kubernetes Node. Perlu diperhatikan bahwa nama Kubernetes Node harus sesuai dengan nama Azure VM.
CloudStack
----------
### Nama Node
Penyedia layanan cloud CloudStack menggunakan _hostname_ dari _node_ (yang ditentukan kubelet atau menggunakan `--hostname-override`) sebagai nama dari objek Kubernetes Node. Perlu diperhatikan bahwa nama Kubernetes Node harus sesuai dengan nama Cloudstack VM.
GCE
---
### Nama Node
Penyedia layanan cloud GCE menggunakan _hostname_ dari _node_ (yang ditentukan kubelet atau menggunakan `--hostname-override`) sebagai nama dari objek Kubernetes Node. Perlu diperhatikan bahwa segmen pertama dari nama Kubernetes Node harus sesuai dengan nama _instance_ GCE (contoh: sebuah _node_ dengan nama `kubernetes-node-2.c.my-proj.internal` harus sesuai dengan _instance_ yang memiliki nama `kubernetes-node-2`).
OpenStack
---------
Bagian ini akan menjelaskan semua konfigurasi yang dapat diatur saat menggunakan OpenStack dengan Kubernetes.
### Nama Node
Penyedia layanan cloud OpenStack menggunakan nama _instance_ (yang diperoleh dari metadata OpenStack) sebagai nama objek Kubernetes Node. Perlu diperhatikan bahwa nama _instance_ harus berupa nama Kubernetes Node yang valid agar kubelet dapat mendaftarkan objek Node-nya.
### Layanan
Penyedia layanan cloud OpenStack menggunakan beragam layanan OpenStack yang tersedia sebagai _underlying cloud_ agar dapat mendukung Kubernetes:
| Layanan | Versi API | Wajib |
| --- | --- | --- |
| Block Storage (Cinder) | V1†, V2, V3 | Tidak |
| Compute (Nova) | V2 | Tidak |
| Identity (Keystone) | V2‡, V3 | Ya |
| Load Balancing (Neutron) | V1§, V2 | Tidak |
| Load Balancing (Octavia) | V2 | Tidak |
† Block Storage V1 API tidak lagi didukung, dukungan Block Storage V3 API telah ditambahkan pada Kubernetes 1.9.
‡ Identity V2 API tidak lagi didukung dan akan dihapus oleh penyedia layanan pada rilis mendatang. Pada rilis "Queens", OpenStack tidak lagi mengekspos Identity V2 API.
§ Dukungan Load Balancing V1 API telah dihapus pada Kubernetes 1.9.
_Service discovery_ dilakukan dengan menggunakan katalog layanan/servis (_service catalog_) yang diatur oleh OpenStack Identity (Keystone) menggunakan `auth-url` yang ditentukan pada konfigurasi penyedia layanan. Penyedia layanan akan menurunkan fungsionalitas secara perlahan saat layanan OpenStack selain Keystone tidak tersedia dan akan menolak dukungan fitur yang terdampak. Beberapa fitur tertentu dapat diaktifkan atau dinonaktfikan tergantung dari ekstensi yang diekspos oleh Neutron pada _underlying cloud_.
### cloud.conf
Kubernetes berinteraksi dengan OpenStack melalui _file_ cloud.conf. _File_ ini akan menyuplai Kubernetes dengan kredensial dan lokasi dari Openstack _auth endpoint_. Kamu dapat membuat _file_ cloud.conf dengan menambahkan rincian berikut ini di dalam _file_:
#### Konfigurasi pada umumnya
Berikut ini merupakan contoh dan konfigurasi yang biasa digunakan dan akan mencakup semua pilihan yang paling sering dibutuhkan. _File_ ini akan merujuk pada _endpoint_ dari Keystone OpenStack, serta menyediakan rincian bagaimana cara mengautentikasi dengannya, termasuk cara mengatur _load balancer_:
[Global]
username=user
password=pass
auth-url=https:///identity/v3
tenant-id=c869168a828847f39f7f06edd7305637
domain-id=2a73b8f597c04551a0fdc8e95544be8a
[LoadBalancer]
subnet-id=6937f8fa-858d-4bc9-a3a5-18d2c957166a
##### Global
Konfigurasi untuk penyedia layanan OpenStack berikut ini akan membahas bagian konfigurasi global sehingga harus berada pada bagian `[Global]` dari _file_ `cloud.conf`:
* `auth-url` (Wajib): URL dari API keystone digunakan untuk autentikasi. ULR ini dapat ditemukan pada bagian Access dan Security > API Access > Credentials di laman panel kontrol OpenStack.
* `username` (Wajib): Merujuk pada username yang dikelola keystone.
* `password` (Wajib): Merujuk pada kata sandi yang dikelola keystone.
* `tenant-id` (Wajib): Digunakan untuk menentukan id dari _project_ tempat kamu membuat _resources_.
* `tenant-name` (Opsional): Digunakan untuk menentukan nama dari _project_ tempat kamu ingin membuat _resources_.
* `trust-id` (Opsional): Digunakan untuk menentukan _identifier of the trust_ untuk digunakan sebagai otorisasi. Suatu _trust_ merepresentasikan otorisasi dari suatu pengguna (_the trustor_) untuk didelegasikan pada pengguna lain (_the trustee_), dan dapat digunakan oleh _trustee_ berperan sebagai _the trustor_. _Trust_ yang tersedia dapat ditemukan pada _endpoint_ `/v3/OS-TRUST/trusts` dari Keystone API.
* `domain-id` (Opsional): Digunakan untuk menentukan id dari domain tempat _user_ kamu berada.
* `domain-name` (Opsional): Digunakan untuk menentukan nama dari domain tempat _user_ kamu berada.
* `region` (Opsional): Digunakan untuk menentukan _identifier_ dari region saat digunakan pada multi-region OpenStack cloud. Sebuah region merupakan pembagian secara umum dari _deployment_ OpenStack. Meskipun region tidak wajib berkorelasi secara geografis, suatu _deployment_ dapat menggunakan nama geografis sebagai region _identifier_ seperti `us-east`. Daftar region yang tersedia dapat ditemukan pada _endpoint_ `/v3/regions` dari Keystone API.
* `ca-file` (Optional): Digunakan untuk menentukan path dari _file_ _custom_ CA.
Saat menggunakan Keystone V3 - yang mengganti istilah _tenant_ menjadi _project_ - nilai `tenant-id` akan secara otomatis dipetakan pada _project_ yang sesuai di API.
##### _Load Balancer_
Konfigurasi berikut ini digunakan untuk mengatur _load balancer_ dan harus berada pada bagian `[LoadBalancer]` dari _file_ `cloud.conf`:
* `lb-version` (Opsional): Digunakan untuk menonaktifkan pendeteksian versi otomatis. Nilai yang valid yaitu `v1` atau `v2`. Jika tidak ditentukan, maka pendeteksian otomatis akan memilih versi tertinggi yang didukung dari _underlying_ OpenStack cloud.
* `use-octavia` (Opsional): Digunakan untuk menentukan apakah akan menggunakan _endpoint_ dari layanan Octavia LBaaS. Nilai yang valid yaitu `true` atau `false`. Jika diset nilai `true` namun Octavia LBaaS V2 tidak dapat ditemukan, maka _load balancer_ akan kembali menggunakan _endpoint_ dari Neutron LBaaS V2. Nilai _default_ adalah `false`.
* `subnet-id` (Opsional): Digunakan untuk menentukan id dari subnet yang ingin kamu buat _load balancer_ di dalamnya. Nilai id ini dapat dilihat pada Network > Networks. Klik pada jaringan yang sesuai untuk melihat subnet di dalamnya.
* `floating-network-id` (Opsional): Jika diset, maka akan membuat _floating_ IP untuk _load balancer_.
* `lb-method` (Opsional): Digunakan untuk menentukan algoritma pendistribusian yang akan digunakan. Nilai yang valid yaitu `ROUND_ROBIN`, `LEAST_CONNECTIONS`, atau `SOURCE_IP`. Jika tidak diset, maka akan menggunakan algoritma _default_ yaitu `ROUND_ROBIN`.
* `lb-provider` (Opsional): Digunakan untuk menentukan penyedia dari _load balancer_. Jika tidak ditentukan, maka akan menggunakan penyedia _default_ yang ditentukan pada Neutron.
* `create-monitor` (Opsional): Digunakan untuk menentukan apakah akan membuat atau tidak monitor kesehatan untuk Neutron _load balancer_. Nilai yang valid yaitu `true` dan `false`. Nilai _default_ adalah `false`. Jika diset nilai `true` maka `monitor-delay`, `monitor-timeout`, dan `monitor-max-retries` juga harus diset.
* `monitor-delay` (Opsional): Waktu antara pengiriman _probes_ ke anggota dari _load balancer_. Mohon pastikan kamu memasukkan waktu yang valid. Nilai waktu yang valid yaitu "ns", "us" (atau "µs"), "ms", "s", "m", "h"
* `monitor-timeout` (Opsional): Waktu maksimum dari monitor untuk menunggu balasan ping sebelum _timeout_. Nilai ini harus lebih kecil dari nilai _delay_. Mohon pastikan kamu memasukkan waktu yang valid. Nilai waktu yang valid yaitu "ns", "us" (atau "µs"), "ms", "s", "m", "h"
* `monitor-max-retries` (Opsional): Jumlah gagal ping yang diizinkan sebelum mengubah status anggota _load balancer_ menjadi INACTIVE. Harus berupa angka antara 1 dan 10.
* `manage-security-groups` (Opsional): Digunakan untuk menentukan apakah _load balancer_ akan mengelola aturan grup keamanan sendiri atau tidak. Nilai yang valid adalah `true` dan `false`. Nilai _default_ adalah `false`. Saat diset ke `true` maka nilai `node-security-group` juga harus ditentukan.
* `node-security-group` (Opsional): ID dari grup keamanan yang akan dikelola.
##### _Block Storage_
Konfigurasi untuk penyedia layanan OpenStack berikut ini digunakan untuk mengatur penyimpanan blok atau _block storage_ dan harus berada pada bagian `[BlockStorage]` dari _file_ `cloud.conf`:
* `bs-version` (Opsional): Digunakan untuk menonaktifkan fitur deteksi versi otomatis. Nilai yang valid yaitu `v1`, `v2`, `v3` dan `auto`. Jika diset ke `auto` maka pendeteksian versi otomatis akan memilih versi tertinggi yang didukung oleh _underlying_ OpenStack cloud. Nilai _default_ jika tidak diset adalah `auto`.
* `trust-device-path` (Opsional): Pada umumnya nama _block device_ yang ditentukan oleh Cinder (contoh: `/dev/vda`) tidak dapat diandalkan. Opsi ini dapat mengatur hal tersebut. Jika diset ke `true` maka akan menggunakan nama _block device_ yang ditentukan oleh Cinder. Nilai _default_ adalah `false` yang berarti _path_ dari _device_ akan ditentukan oleh nomor serialnya serta pemetaan dari `/dev/disk/by-id`, dan ini merupakan cara yang direkomendasikan.
* `ignore-volume-az` (Opsional): Digunakan untuk mengatur penggunaan _availability zone_ saat menautkan volumes Cinder. Jika Nova dan Cinder memiliki _availability zones_ yang berbeda, opsi ini harus diset `true`. Skenario seperti ini yang umumnya terjadi, yaitu saat terdapat banyak Nova _availability zones_ namun hanya ada satu Cinder _availability zone_. Nilai _default_ yaitu `false` digunakan untuk mendukung penggunaan pada rilis terdahulu, tetapi nilai ini dapat berubah pada rilis mendatang.
Jika menjalankan Kubernetes dengan versi <= 1.8 pada OpenStack yang menggunakan _paths_ alih-alih menggunakan port untuk membedakan antara _endpoints_, maka mungkin dibutuhkan untuk secara eksplisit mengatur parameter `bs-version`. Contoh _endpoint_ yang berdasarkan _path_ yaitu `http://foo.bar/volume` sedangkan endpoint yang berdasarkan port memiliki bentuk seperti ini `http://foo.bar:xxx`.
Pada lingkungan yang menggunakan _endpoint_ berdasarkan _path_ dan Kubernetes menggunakan logika deteksi-otomatis yang lama, maka _error_ `BS API version autodetection failed.` akan muncul saat mencoba melepaskan volume. Untuk mengatasi isu ini, dimungkinkan untuk memaksa penggunaan Cinder API versi 2 dengan menambahkan baris berikut ini pada konfigurasi penyedia cloud:
[BlockStorage]
bs-version=v2
##### Metadata
Konfigurasi untuk OpenStack berikut ini digunakan untuk mengatur metadata dan harus berada pada bagian `[Metadata]` dari _file_ `cloud.conf`:
* `search-order` (Opsional): Konfigurasi berikut ini digunakan untuk mengatur bagaimana cara provider mengambil metadata terkait dengan _instance_ yang dijalankannya. Nilai _default_ yaitu `configDrive,metadataService` yang berarti provider akan mengambil metadata terkait _instance_ dari _config drive_ terlebih dahulu jika tersedia, namun jika tidak maka akan menggunakan layanan metadata. Nilai alternatif lainnya yaitu:
* `configDrive` - Hanya mengambil metadata _instance_ dari _config drive_.
* `metadataService` - Hanya mengambil data _instance_ dari layanan metadata.
* `metadataService,configDrive` - Mengambil metadata _instance_ dari layanan metadata terlebih dahulu jika tersedia, jika tidak maka akan mengambil dari _config drive_.
Pengaturan ini memang sebaiknya dilakukan sebab metadata pada _config drive_ bisa saja lambat laun akan kedaluwarsa, sedangkan layanan metadata akan selalu menyediakan metadata yang paling mutakhir. Tidak semua penyedia layanan cloud OpenStack menyediakan kedua layanan _config drive_ dan layanan metadata dan mungkin hanya salah satu saja yang tersedia. Oleh sebab itu nilai _default_ diatur agar dapat memeriksa keduanya.
##### Router
Konfigurasi untuk Openstack berikut ini digunakan untuk mengatur _plugin_ jaringan Kubernetes [kubenet](https://kubernetes.io/docs/concepts/cluster-administration/network-plugins/#kubenet)
dan harus berada pada bagian `[Router]` dari _file_ `cloud.conf`:
* `router-id` (Opsional): Jika Neutron pada _underlying cloud_ mendukung ekstensi `extraroutes` maka gunakan `router-id` untuk menentukan router mana yang akan ditambahkan rute di dalamnya. Router yang dipilih harus menjangkau jaringan privat tempat _node_ klaster berada (biasanya hanya ada satu jaringan _node_, dan nilai ini harus nilai dari _default_ router pada jaringan _node_). Nilai ini dibutuhkan untuk dapat menggunakan [kubenet](https://kubernetes.io/docs/concepts/cluster-administration/network-plugins/#kubenet)
pada OpenStack.
OVirt
-----
### Nama Node
Penyedia layanan cloud OVirt menggunakan _hostname_ dari _node_ (yang ditentukan kubelet atau menggunakan `--hostname-override`) sebagai nama dari objek Kubernetes Node. Perlu diperhatikan bahwa nama Kubernetes Node harus sesuai dengan VM FQDN (yang ditampilkan oleh OVirt di bawah `...`)
Photon
------
### Nama Node
Penyedia layanan cloud Photon menggunakan _hostname_ dari _node_ (yang ditentukan kubelet atau menggunakan `--hostname-override`) sebagai nama dari objek Kubernetes Node. Perlu diperhatikan bahwa nama Kubernetes Node name harus sesuai dengan nama Photon VM (atau jika `overrideIP` diset ke true pada `--cloud-config`, nama Kubernetes Node harus sesuai dengan alamat IP Photon VM).
VSphere
-------
### Nama Node
Penyedia layanan cloud VSphere menggunakan _hostname_ yang terdeteksi dari _node_ (yang ditentukan oleh kubelet) sebagai nama dari objek Kubernetes Node.
Parameter `--hostname-override` diabaikan oleh penyedia layanan cloud VSphere.
IBM Cloud Kubernetes Service
----------------------------
### Node Komputasi
Saat menggunakan layanan IBM Cloud Kubernetes Service, kamu dapat membuat klaster yang terdiri dari campuran antara mesin virtual dan fisik (_bare metal_) sebagai _node_ di _single zone_ atau _multiple zones_ pada satu region. Untuk informasi lebih lanjut, lihat [Perencanaan klaster dan pengaturan worker node](https://cloud.ibm.com/docs/containers?topic=containers-plan_clusters#plan_clusters)
.
Nama dari objek Kubernetes Node yaitu alamat IP privat dari IBM Cloud Kubernetes Service _worker node instance_.
### Jaringan
Penyedia layanan IBM Cloud Kubernetes Service menyediakan VLAN untuk membuat jaringan node yang terisolasi dengan kinerja tinggi. Kamu juga dapat membuat _custom firewall_ dan _policy_ jaringan Calico untuk menambah lapisan perlindungan ekstra bagi klaster kamu, atau hubungkan klaster kamu dengan _on-prem_ data center via VPN. Untuk informasi lebih lanjut, lihat [Perencanaan jaringan privat dan in-cluster](https://cloud.ibm.com/docs/containers?topic=containers-cs_network_cluster#cs_network_cluster)
.
Untuk membuka aplikasi ke publik atau di dalam klaster, kamu dapat menggunakan NodePort, LoadBalancer, atau Ingress. Kamu juga dapat menyesuaikan aplikasi _load balancer_ Ingress dengan anotasi. Untuk informasi lebih lanjut, lihat [Perencanaan untuk membuka aplikasi dengan jaringan eksternal](https://cloud.ibm.com/docs/containers?topic=containers-cs_network_planning#cs_network_planning)
.
### Penyimpanan
Penyedia layanan IBM Cloud Kubernetes Service memanfaatkan Kubernetes-native _persistent volumes_ agar pengguna dapat melakukan _mount_ _file_, block, dan penyimpanan objek cloud ke aplikasi mereka. Kamu juga dapat menggunakan _database-as-a-service_ dan _add-ons_ pihak ketiga sebagai penyimpanan _persistent_ untuk data kamu. Untuk informasi lebih lanjut, lihat [Perencanaan penyimpanan persistent yang selalu tersedia (_highly available_)](https://cloud.ibm.com/docs/containers?topic=containers-storage_planning#storage_planning)
.
Baidu Cloud Container Engine
----------------------------
### Nama Node
Penyedia layanan cloud Baidu menggunakan alamat IP privat dari _node_ (yang ditentukan oleh kubelet atau menggunakan `--hostname-override`) sebagai nama dari objek Kubernetes Node. Perlu diperhatikan bahwa nama Kubernetes Node harus sesuai dengan alamat IP privat dari Baidu VM.
4 - Mengelola Resource
======================
Kamu telah melakukan _deploy_ pada aplikasimu dan mengeksposnya melalui sebuah _service_. Lalu? Kubernetes menyediakan berbagai peralatan untuk membantu mengatur mekanisme _deploy_ aplikasi, termasuk pengaturan kapasitas dan pembaruan. Diantara fitur yang akan didiskusikan lebih mendalam yaitu [berkas konfigurasi](https://kubernetes.io/id/docs/concepts/configuration/overview/)
dan [label](https://kubernetes.io/id/docs/concepts/overview/working-with-objects/labels/)
.
Mengelola konfigurasi _resource_
--------------------------------
Banyak aplikasi memerlukan beberapa _resource_, seperti Deployment dan Service. Pengelolaan beberapa _resource_ dapat disederhanakan dengan mengelompokkannya dalam berkas yang sama (dengan pemisah `---` pada YAML). Contohnya:
[`application/nginx-app.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/id/examples/application/nginx-app.yaml)

apiVersion: v1
kind: Service
metadata:
name: my-nginx-svc
labels:
app: nginx
spec:
type: LoadBalancer
ports:
- port: 80
selector:
app: nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-nginx
labels:
app: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.7.9
ports:
- containerPort: 80
Beberapa _resource_ dapat dibuat seolah-olah satu _resource_:
kubectl apply -f https://k8s.io/examples/application/nginx-app.yaml
service/my-nginx-svc created
deployment.apps/my-nginx created
_Resource_ akan dibuat dalam urutan seperti pada berkas. Oleh karena itu, lebih baik menyalakan _service_ lebih dahulu agar menjamin _scheduler_ dapat menyebar _pod_ yang terkait _service_ selagi _pod_ dibangkitkan oleh _controller_, seperti Deployment.
`kubectl apply` juga dapat menerima beberapa argumen `-f`:
kubectl apply -f https://k8s.io/examples/application/nginx/nginx-svc.yaml -f https://k8s.io/examples/application/nginx/nginx-deployment.yaml
Selain berkas, kita dapat juga memasukkan direktori sebagai argumen:
kubectl apply -f https://k8s.io/examples/application/nginx/
`kubectl` akan membaca berkas apapun yang berakhiran `.yaml`, `.yml`, or `.json`.
Sangat disarankan untuk meletakkan sumber daya yang ada dalam _microservice_ atau _tier_ aplikasi yang sama dalam satu berkas, dan mengelompokkan semua berkas terkait aplikasimu dalam satu direktori. Jika _tier_ masing-masing aplikasi terikat dengan DNS, maka kamu dapat melakukan _deploy_ semua komponen teknologi yang dibutuhkan bersama-sama.
Lokasi konfigurasi dapat juga diberikan dalam bentuk URL. Ini berguna ketika ingin menjalankan berkas konfigurasi dari Github:
kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/master/content/en/examples/application/nginx/nginx-deployment.yaml
deployment.apps/my-nginx created
Operasi majemuk dalam kubectl
-----------------------------
Pembuatan _resource_ bukanlah satu-satunya operasi yang bisa dijalankan `kubectl` secara majemuk. Contoh lainnya adalah mengekstrak nama _resource_ dari berkas konfigurasi untuk menjalankan operasi lainnya, seperti untuk menghapus _resource_ yang telah dibuat:
kubectl delete -f https://k8s.io/examples/application/nginx-app.yaml
deployment.apps "my-nginx" deleted
service "my-nginx-svc" deleted
Pada kasus dua _resource_, mudah untuk memasukkan keduanya pada _command line_ menggunakan sintaks _resource_/nama:
kubectl delete deployments/my-nginx services/my-nginx-svc
Namun, untuk _resource_ yang lebih banyak, memasukkan selektor (_label query_) menggunakan `-l` atau `--selector` untuk memfilter _resource_ berdasarkan label akan lebih mudah:
kubectl delete deployment,services -l app=nginx
deployment.apps "my-nginx" deleted
service "my-nginx-svc" deleted
Karena `kubectl` mengembalikan nama resource yang sama dengan sintaks yang diterima, mudah untuk melanjutkan operasi menggunakan `$()` atau `xargs`:
kubectl get $(kubectl create -f docs/concepts/cluster-administration/nginx/ -o name | grep service)
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-nginx-svc LoadBalancer 10.0.0.208 80/TCP 0s
Dengan perintah di atas, pertama kita buat resource di dalam `examples/application/nginx/`. Lalu tampilkan resources yang terbentuk dengan format keluaran `-o name` (menampilkan tiap resource dalam format resource/nama). Kemudian lakukan `grep` hanya pada "service", dan tampilkan dengan `kubectl get`.
Untuk dapat menggunakan perintah di atas pada direktori yang bertingkat, kamu dapat memberi argumen `--recursive` atau `-R` bersama dengan argumen `--filename,-f`.
Misalnya ada sebuah direktori `project/k8s/development` memuat semua manifests yang berkaitan dengan _development environment_. Manifest akan tersusun berdasarkan tipe resource:
project/k8s/development
├── configmap
│ └── my-configmap.yaml
├── deployment
│ └── my-deployment.yaml
└── pvc
└── my-pvc.yaml
Secara _default_, menjalankan operasi majemuk pada `project/k8s/development` hanya akan terbatas pada direktori terluar saja. Sehingga ketika kita menjalankan operasi pembuatan dengan perintah berikut, kita akan mendapatkan pesan kesalahan:
kubectl apply -f project/k8s/development
error: you must provide one or more resources by argument or filename (.json|.yaml|.yml|stdin)
Solusinya, tambahkan argumen `--recursive` atau `-R` bersama dengan `--filename,-f`, seperti:
kubectl apply -f project/k8s/development --recursive
configmap/my-config created
deployment.apps/my-deployment created
persistentvolumeclaim/my-pvc created
Argumen `--recursive` berjalan pada operasi apapun yang menerima argumen `--filename,-f` seperti: `kubectl {create,get,delete,describe,rollout} etc.`
Argumen `--recursive` juga berjalan saat beberapa argumen `-f` diberikan:
kubectl apply -f project/k8s/namespaces -f project/k8s/development --recursive
namespace/development created
namespace/staging created
configmap/my-config created
deployment.apps/my-deployment created
persistentvolumeclaim/my-pvc created
Jika kamu tertarik mempelajari lebih lanjut tentang `kubectl`, silahkan baca [Ikhtisar kubectl](https://kubernetes.io/id/docs/reference/kubectl/overview/)
.
Memakai label secara efektif
----------------------------
Contoh yang kita lihat sejauh ini hanya menggunakan paling banyak satu label pada _resource_. Ada banyak skenario ketika membutuhkan beberapa label untuk membedakan sebuah kelompok dari yang lainnya.
Sebagai contoh, aplikasi yang berbeda akan menggunakan label `app` yang berbeda, tapi pada aplikasi _multitier_, seperti pada [contoh buku tamu](https://github.com/kubernetes/examples/tree/main/guestbook/)
, tiap _tier_ perlu dibedakan. Misal untuk menandai _tier frontend_ bisa menggunakan label:
labels:
app: guestbook
tier: frontend
sementara itu Redis _master_ dan _slave_ memiliki label `tier` yang berbeda. Bisa juga menggunakan label tambahan `role`:
labels:
app: guestbook
tier: backend
role: master
dan
labels:
app: guestbook
tier: backend
role: slave
Label memungkinkan kita untuk memilah _resource_ dengan pembeda berupa label:
kubectl apply -f examples/guestbook/all-in-one/guestbook-all-in-one.yaml
kubectl get pods -Lapp -Ltier -Lrole
NAME READY STATUS RESTARTS AGE APP TIER ROLE
guestbook-fe-4nlpb 1/1 Running 0 1m guestbook frontend
guestbook-fe-ght6d 1/1 Running 0 1m guestbook frontend
guestbook-fe-jpy62 1/1 Running 0 1m guestbook frontend
guestbook-redis-master-5pg3b 1/1 Running 0 1m guestbook backend master
guestbook-redis-slave-2q2yf 1/1 Running 0 1m guestbook backend slave
guestbook-redis-slave-qgazl 1/1 Running 0 1m guestbook backend slave
my-nginx-divi2 1/1 Running 0 29m nginx
my-nginx-o0ef1 1/1 Running 0 29m nginx
kubectl get pods -lapp=guestbook,role=slave
NAME READY STATUS RESTARTS AGE
guestbook-redis-slave-2q2yf 1/1 Running 0 3m
guestbook-redis-slave-qgazl 1/1 Running 0 3m
Deploy dengan Canary
--------------------
Skenario lain yang menggunakan beberapa label yaitu saat membedakan deployment komponen yang sama namun dengan rilis atau konfigurasi yang berbeda. Adalah praktik yang umum untuk mendeploy sebuah _canary_ dari rilis aplikasi yang baru (berdasarkan _tag image_ dalam templat _pod_) bersamaan dengan rilis sebelumnya. Ini memungkinkan rilis yang baru dapat menerima _live traffic_ sebelum benar-benar menggantikan rilis yang lama.
Salah satu alternatif yaitu kamu dapat memakai label `track` untuk membedakan antar rilis.
Rilis primer dan stabil akan memiliki label `track` yang berisi `stable`:
name: frontend
replicas: 3
...
labels:
app: guestbook
tier: frontend
track: stable
...
image: gb-frontend:v3
kemudian kamu buat lagi rilis _frontend_ buku tamu yang membawa label `track` yang berbeda (misal `canary`), sehingga _pod_ dalam kedua rilis tidak beririsan:
name: frontend-canary
replicas: 1
...
labels:
app: guestbook
tier: frontend
track: canary
...
image: gb-frontend:v4
Servis _frontend_ akan meliputi kedua set replika dengan menentukan subset bersama dari para labelnya (tanpa `track`). Sehingga _traffic_ akan diarahkan ke kedua aplikasi:
selector:
app: guestbook
tier: frontend
Kamu dapat mengatur jumlah replika rilis _stable_ dan _canary_ untuk menentukan rasio dari tiap rilis yang akan menerima _traffic production live_ (dalam kasus ini 3:1). Ketika telah yakin, kamu dapat memindahkan _track stable_ ke rilis baru dan menghapus _canary_.
Untuk contoh yang lebih jelas, silahkan cek [tutorial melakukan deploy Ghost](https://github.com/kelseyhightower/talks/tree/master/kubecon-eu-2016/demo#deploy-a-canary)
.
Memperbarui label
-----------------
Kadang, _pod_ dan _resource_ lain yang sudah ada harus dilabeli ulang sebelum membuat _resource_ baru. Hal ini dapat dilakukan dengan perintah `kubectl label`. Contohnya jika kamu ingin melabeli ulang semua _pod_ nginx sebagai _frontend tier_, tinggal jalankan:
kubectl label pods -l app=nginx tier=fe
pod/my-nginx-2035384211-j5fhi labeled
pod/my-nginx-2035384211-u2c7e labeled
pod/my-nginx-2035384211-u3t6x labeled
Perintah ini melakukan filter pada semua _pod_ dengan label "app=nginx", lalu melabelinya dengan "tier=fe". Untuk melihat _pod_ yang telah dilabeli, jalankan:
kubectl get pods -l app=nginx -L tier
NAME READY STATUS RESTARTS AGE TIER
my-nginx-2035384211-j5fhi 1/1 Running 0 23m fe
my-nginx-2035384211-u2c7e 1/1 Running 0 23m fe
my-nginx-2035384211-u3t6x 1/1 Running 0 23m fe
Akan muncul semua _pod_ dengan "app=nginx" dan sebuah kolom label tambahan yaitu tier (ditentukan dengan `-L` atau `--label-columns`).
Untuk informasi lebih lanjut, silahkan baca [label](https://kubernetes.io/id/docs/concepts/overview/working-with-objects/labels/)
dan [kubectl label](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#label)
.
Memperbarui anotasi
-------------------
Kadang resource perlu ditambahkan anotasi. Anotasi adalah metadata sembarang yang tidak unik, seperti _tools, libraries_, dsb yang digunakan oleh klien API . Ini dapat dilakukan dengan `kubectl annotate`. Sebagai contoh:
kubectl annotate pods my-nginx-v4-9gw19 description='my frontend running nginx'
kubectl get pods my-nginx-v4-9gw19 -o yaml
apiVersion: v1
kind: pod
metadata:
annotations:
description: my frontend running nginx
...
Untuk informasi lebih lanjut, silahkan lihat laman [annotations](https://kubernetes.io/id/docs/concepts/overview/working-with-objects/annotations/)
dan [kubectl annotate](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#annotate)
.
Memperbesar dan memperkecil aplikasi kamu
-----------------------------------------
Saat beban aplikasi naik maupun turun, mudah untuk mengubah kapasitas dengan `kubectl`. Contohnya, untuk menurunkan jumlah replika nginx dari 3 ke 1, lakukan:
kubectl scale deployment/my-nginx --replicas=1
deployment.apps/my-nginx scaled
Sekarang kamu hanya memiliki satu _pod_ yang dikelola oleh deployment.
kubectl get pods -l app=nginx
NAME READY STATUS RESTARTS AGE
my-nginx-2035384211-j5fhi 1/1 Running 0 30m
Agar sistem dapat menyesuaikan jumlah replika nginx yang dibutuhkan secara otomatis dari 1 hingga 3, lakukan:
kubectl autoscale deployment/my-nginx --min=1 --max=3
horizontalpodautoscaler.autoscaling/my-nginx autoscaled
Sekarang jumlah replika nginx akan secara otomatis naik dan turun sesuai kebutuhan.
Informasi tambahan dapat dilihat pada dokumen [kubectl scale](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#scale)
, [kubectl autoscale](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#autoscale)
dan [horizontal _pod_ autoscaler](https://kubernetes.io/id/docs/tasks/run-application/horizontal-pod-autoscale/)
.
Pembaruan resource di tempat
----------------------------
Kadang kita perlu membuat pembaruan kecil, yang tidak mengganggu pada _resource_ yang telah dibuat.
### kubectl apply
Disarankan untuk menyimpan berkas-berkas konfigurasi dalam _source control_ (lihat [konfigurasi sebagai kode](http://martinfowler.com/bliki/InfrastructureAsCode.html)
). Sehingga berkas dapat dipelihara dan diatur dalam versi bersama dengan kode milik _resource_ yang diatur oleh konfigurasi tersebut. Berikutnya, kamu dapat menggunakan [`kubectl apply`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#apply)
untuk membarui perubahan konfigurasi ke klaster.
Perintah ini akan membandingkan versi konfigurasi yang disuplai dengan versi sebelumnya yang telah berjalan dan memasang perubahan yang kamu buat tanpa mengganti properti yang tidak berubah sama sekali.
kubectl apply -f https://k8s.io/examples/application/nginx/nginx-deployment.yaml
deployment.apps/my-nginx configured
Perhatikan bahwa `kubectl apply` memasang anotasi pada _resource_ untuk menentukan perubahan pada konfigurasi sejak terakhir dipanggil. Ketika dijalankan, `kubectl apply` melakukan pembandingan _three-way_ antara konfigurasi sebelumnya, masukan yang disuplai, dan konfigurasi _resource_ sekarang, untuk dapat menentukan cara memodifikasi _resource_.
Saat ini, _resource_ dibuat tanpa ada anotasi. Jadi pemanggilan pertama pada `kubectl apply` akan dikembalikan pada perbandingan _two-way_ antara masukan pengguna dan konfigurasi _resource_ sekarang. Saat pemanggilan pertama ini, tidak ada penghapusan set properti yang terdeteksi saat _resource_ dibuat. Sehingga, tidak ada yang dihapus.
Tiap `kubectl apply`, atau perintah lain yang memodifikasi konfigurasi seperti `kubectl replace` dan `kubectl edit` dijalankan, anotasi akan diperbarui. Sehingga memungkinkan operasi `kubectl apply` untuk mendeteksi dan melakukan penghapusan secara perbandingan _three-way_.
### kubectl edit
Sebagai alternatif, kamu juga dapat membarui resource dengan `kubectl edit`:
kubectl edit deployment/my-nginx
Ini sama dengan melakukan `get` pada _resource_, mengubahnya di text editor, kemudian menjalankan`apply` pada _resource_ dengan versi terkini:
kubectl get deployment my-nginx -o yaml > /tmp/nginx.yaml
vi /tmp/nginx.yaml
# lakukan pengubahan, lalu simpan berkas
kubectl apply -f /tmp/nginx.yaml
deployment.apps/my-nginx configured
rm /tmp/nginx.yaml
Cara demikian memungkinkan kamu membuat perubahan signifikan dengan mudah. Lihat bahwa kamu juga dapat menentukan editor dengan variabel environment `EDITOR` atau `KUBE_EDITOR`.
Untuk informasi tambahan, silahkan lihat laman [kubectl edit](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#edit)
.
### kubectl patch
Kamu dapat menggunakan `kubectl patch` untuk membarui obyek API di tempat. Perintah ini mendukung patch JSON, _patch_ gabungan JSON, dan _strategic merge patch_. Lihat [Update API Objects in Place Using kubectl patch](https://kubernetes.io/docs/tasks/run-application/update-api-object-kubectl-patch/)
dan [kubectl patch](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#patch)
.
Pembaruan disruptif
-------------------
Pada kasus tertentu, kamu mungkin perlu memperbarui field resource yang tidak dapat diperbarui setelah diinisiasi atau kamu ingin membuat perubahan rekursif segera, seperti memperbaiki _pod_ yang rusak saat menjalankan Deployment. Untuk mengubah field seperti itu, gunakan `replace --force` yang akan menghapus dan membuat ulang resource. Dalam kasus ini kamu dapat mengubah berkas konfigurasi awalnya:
kubectl replace -f https://k8s.io/examples/application/nginx/nginx-deployment.yaml --force
deployment.apps/my-nginx deleted
deployment.apps/my-nginx replaced
Membarui aplikasi tanpa memadamkan servis
-----------------------------------------
Suatu saat, kamu akan perlu untuk membarui aplikasi yang telah terdeploy, biasanya dengan mengganti _image_ atau _tag_ sebagaimana dalam skenario _canary deployment_ di atas. `kubectl` mendukung beberapa operasi pembaruan, masing-masing dapat digunakan pada skenario berbeda.
Kami akan memandumu untuk membuat dan membarui aplikasi melalui Deployment.
Misal kamu telah menjalankan nginx versi 1.7.9:
kubectl run my-nginx --image=nginx:1.7.9 --replicas=3
deployment.apps/my-nginx created
Untuk memperbarui versi ke 1.9.1, ganti `.spec.template.spec.containers[0].image` dari `nginx:1.7.9` ke `nginx:1.9.1`, dengan perintah kubectl yang telah dipelajari di atas.
kubectl edit deployment/my-nginx
Selesai! Deployment akan memperbarui aplikasi nginx yang terdeploy secara berangsur di belakang. Dia akan menjamin hanya ada sekian replika lama yang akan down selagi pembaruan berjalan dan hanya ada sekian replika baru akan dibuat melebihi jumlah pod. Untuk mempelajari lebih lanjut, kunjungi [laman Deployment](https://kubernetes.io/id/docs/concepts/workloads/controllers/deployment/)
.
Selanjutnya
-----------
* [Pelajari tentang bagaimana memakai `kubectl` untuk memeriksa dan _debug_ aplikasi.](https://kubernetes.io/id/docs/tasks/debug-application-cluster/debug-application-introspection/)
* [Praktik Terbaik dan Tips Konfigurasi](https://kubernetes.io/id/docs/concepts/configuration/overview/)
5 - Jaringan Klaster
====================
Jaringan adalah bagian utama dari Kubernetes, tetapi bisa menjadi sulit untuk memahami persis bagaimana mengharapkannya bisa bekerja. Ada 4 masalah yang berbeda untuk diatasi:
1. Komunikasi antar kontainer yang sangat erat: hal ini diselesaikan oleh [Pod](https://kubernetes.io/id/docs/concepts/workloads/pods/pod/)
dan komunikasi `localhost`.
2. Komunikasi antar Pod: ini adalah fokus utama dari dokumen ini.
3. Komunikasi Pod dengan Service: ini terdapat di [Service](https://kubernetes.io/id/docs/concepts/services-networking/service/)
.
4. Komunikasi eksternal dengan Service: ini terdapat di [Service](https://kubernetes.io/id/docs/concepts/services-networking/service/)
.
Kubernetes adalah tentang berbagi mesin antar aplikasi. Pada dasarnya, saat berbagi mesin harus memastikan bahwa dua aplikasi tidak mencoba menggunakan _port_ yang sama. Mengkoordinasikan _port_ di banyak pengembang sangat sulit dilakukan pada skala yang berbeda dan memaparkan pengguna ke masalah tingkat klaster yang di luar kendali mereka.
Alokasi _port_ yang dinamis membawa banyak komplikasi ke sistem - setiap aplikasi harus menganggap _port_ sebagai _flag_, _server_ API harus tahu cara memasukkan nomor _port_ dinamis ke dalam blok konfigurasi, Service-Service harus tahu cara menemukan satu sama lain, dll. Sebaliknya daripada berurusan dengan ini, Kubernetes mengambil pendekatan yang berbeda.
Model jaringan Kubernetes
-------------------------
Setiap Pod mendapatkan alamat IP sendiri. Ini berarti kamu tidak perlu secara langsung membuat tautan antara Pod dan kamu hampir tidak perlu berurusan dengan memetakan _port_ kontainer ke _port_ pada _host_. Ini menciptakan model yang bersih, kompatibel dengan yang sebelumnya dimana Pod dapat diperlakukan seperti halnya VM atau _host_ fisik dari perspektif alokasi _port_, penamaan, _service discovery_, _load balancing_, konfigurasi aplikasi, dan migrasi.
Kubernetes memberlakukan persyaratan mendasar berikut pada setiap implementasi jaringan (kecuali kebijakan segmentasi jaringan yang disengaja):
* Pod pada suatu Node dapat berkomunikasi dengan semua Pod pada semua Node tanpa NAT
* agen pada suatu simpul (mis. _daemon_ sistem, kubelet) dapat berkomunikasi dengan semua Pod pada Node itu
Catatan: Untuk platform yang mendukung Pod yang berjalan di jaringan _host_ (mis. Linux):
* Pod di jaringan _host_ dari sebuah Node dapat berkomunikasi dengan semua Pod pada semua Node tanpa NAT
Model ini tidak hanya sedikit kompleks secara keseluruhan, tetapi pada prinsipnya kompatibel dengan keinginan Kubernetes untuk memungkinkan _low-friction porting_ dari aplikasi dari VM ke kontainer. Jika pekerjaan kamu sebelumnya dijalankan dalam VM, VM kamu memiliki IP dan dapat berbicara dengan VM lain di proyek yang sama. Ini adalah model dasar yang sama.
Alamat IP Kubernetes ada di lingkup Pod - kontainer dalam Pod berbagi jaringan _namespace_ mereka - termasuk alamat IP mereka. Ini berarti bahwa kontainer dalam Pod semua dapat mencapai _port_ satu sama lain di `_localhost_`. Ini juga berarti bahwa kontainer dalam Pod harus mengoordinasikan penggunaan _port_, tetapi ini tidak berbeda dari proses di VM. Ini disebut model "IP-per-pod".
Bagaimana menerapkan model jaringan Kubernetes
----------------------------------------------
Ada beberapa cara agar model jaringan ini dapat diimplementasikan. Dokumen ini bukan studi lengkap tentang berbagai metode, tetapi semoga berfungsi sebagai pengantar ke berbagai teknologi dan berfungsi sebagai titik awal.
Opsi jaringan berikut ini disortir berdasarkan abjad - urutan tidak menyiratkan status istimewa apa pun.
### ACI
[Infrastruktur Sentral Aplikasi Cisco](https://www.cisco.com/c/en/us/solutions/data-center-virtualization/application-centric-infrastructure/index.html)
menawarkan solusi SDN overlay dan underlay terintegrasi yang mendukung kontainer, mesin virtual, dan _bare metal server_. [ACI](https://www.github.com/noironetworks/aci-containers)
menyediakan integrasi jaringan kontainer untuk ACI. Tinjauan umum integrasi disediakan [di sini](https://www.cisco.com/c/dam/en/us/solutions/collateral/data-center-virtualization/application-centric-infrastructure/solution-overview-c22-739493.pdf)
.
### AOS dari Apstra
[AOS](http://www.apstra.com/products/aos/)
adalah sistem Jaringan Berbasis Intent yang menciptakan dan mengelola lingkungan pusat data yang kompleks dari platform terintegrasi yang sederhana. AOS memanfaatkan desain terdistribusi sangat _scalable_ untuk menghilangkan pemadaman jaringan sambil meminimalkan biaya.
Desain Referensi AOS saat ini mendukung _host_ yang terhubung dengan Lapis-3 yang menghilangkan masalah peralihan Lapis-2 yang lama. Host Lapis-3 ini bisa berupa _server_ Linux (Debian, Ubuntu, CentOS) yang membuat hubungan tetangga BGP secara langsung dengan _top of rack switches_ (TORs). AOS mengotomatisasi kedekatan perutean dan kemudian memberikan kontrol yang halus atas _route health injections_ (RHI) yang umum dalam _deployment_ Kubernetes.
AOS memiliki banyak kumpulan endpoint REST API yang memungkinkan Kubernetes dengan cepat mengubah kebijakan jaringan berdasarkan persyaratan aplikasi. Peningkatan lebih lanjut akan mengintegrasikan model Grafik AOS yang digunakan untuk desain jaringan dengan penyediaan beban kerja, memungkinkan sistem manajemen ujung ke ujung untuk layanan cloud pribadi dan publik.
AOS mendukung penggunaan peralatan vendor umum dari produsen termasuk Cisco, Arista, Dell, Mellanox, HPE, dan sejumlah besar sistem white-box dan sistem operasi jaringan terbuka seperti Microsoft SONiC, Dell OPX, dan Cumulus Linux.
Detail tentang cara kerja sistem AOS dapat diakses di sini: [http://www.apstra.com/products/how-it-works/](http://www.apstra.com/products/how-it-works/)
### AWS VPC CNI untuk Kubernetes
[AWS VPC CNI](https://github.com/aws/amazon-vpc-cni-k8s)
menawarkan jaringan AWS _Virtual Private Cloud_ (VPC) terintegrasi untuk klaster Kubernetes. Plugin CNI ini menawarkan _throughput_ dan ketersediaan tinggi, latensi rendah, dan _jitter_ jaringan minimal. Selain itu, pengguna dapat menerapkan jaringan AWS VPC dan praktik keamanan terbaik untuk membangun klaster Kubernetes. Ini termasuk kemampuan untuk menggunakan catatan aliran VPC, kebijakan perutean VPC, dan grup keamanan untuk isolasi lalu lintas jaringan.
Menggunakan _plugin_ CNI ini memungkinkan Pod Kubernetes memiliki alamat IP yang sama di dalam Pod seperti yang mereka lakukan di jaringan VPC. CNI mengalokasikan AWS _Elastic Networking Interfaces_ (ENIs) ke setiap node Kubernetes dan menggunakan rentang IP sekunder dari setiap ENI untuk Pod pada Node. CNI mencakup kontrol untuk pra-alokasi ENI dan alamat IP untuk waktu mulai Pod yang cepat dan memungkinkan klaster besar hingga 2.000 Node.
Selain itu, CNI dapat dijalankan bersama [Calico untuk penegakan kebijakan jaringan](https://docs.aws.amazon.com/eks/latest/userguide/calico.html)
. Proyek AWS VPC CNI adalah _open source_ dengan [dokumentasi di GitHub](https://github.com/aws/amazon-vpc-cni-k8s)
.
### Big Cloud Fabric dari Big Switch Networks
[Big Cloud Fabric](https://www.bigswitch.com/container-network-automation)
adalah arsitektur jaringan asli layanan cloud, yang dirancang untuk menjalankan Kubernetes di lingkungan cloud pribadi / lokal. Dengan menggunakan SDN fisik & _virtual_ terpadu, Big Cloud Fabric menangani masalah yang sering melekat pada jaringan kontainer seperti penyeimbangan muatan, visibilitas, pemecahan masalah, kebijakan keamanan & pemantauan lalu lintas kontainer.
Dengan bantuan arsitektur multi-penyewa Pod virtual pada Big Cloud Fabric, sistem orkestrasi kontainer seperti Kubernetes, RedHat OpenShift, Mesosphere DC/OS & Docker Swarm akan terintegrasi secara alami bersama dengan sistem orkestrasi VM seperti VMware, OpenStack & Nutanix. Pelanggan akan dapat terhubung dengan aman berapa pun jumlah klasternya dan memungkinkan komunikasi antar penyewa di antara mereka jika diperlukan.
Terbaru ini BCF diakui oleh Gartner sebagai visioner dalam [_Magic Quadrant_](http://go.bigswitch.com/17GatedDocuments-MagicQuadrantforDataCenterNetworking_Reg.html)
. Salah satu penyebaran BCF Kubernetes di tempat (yang mencakup Kubernetes, DC/OS & VMware yang berjalan di beberapa DC di berbagai wilayah geografis) juga dirujuk [di sini](https://portworx.com/architects-corner-kubernetes-satya-komala-nio/)
.
### Cilium
[Cilium](https://github.com/cilium/cilium)
adalah perangkat lunak _open source_ untuk menyediakan dan secara transparan mengamankan konektivitas jaringan antar kontainer aplikasi. Cilium mengetahui L7/HTTP dan dapat memberlakukan kebijakan jaringan pada L3-L7 menggunakan model keamanan berbasis identitas yang dipisahkan dari pengalamatan jaringan.
### CNI-Genie dari Huawei
[CNI-Genie](https://github.com/Huawei-PaaS/CNI-Genie)
adalah _plugin_ CNI yang memungkinkan Kubernetes \[secara bersamaan memiliki akses ke berbagai implementasi\]([https://github.com/Huawei-PaaS](https://github.com/Huawei-PaaS)
/CNI-Genie/blob/master/docs/multiple-cni-plugins/README.md#what-cni-genie-feature-1-multiple-cni-plugins-enables) dari \[model jaringan Kubernetes\] ([https://git.k8s.io/website/docs/concepts/cluster-administration/networking.md#kubernetes-model](https://git.k8s.io/website/docs/concepts/cluster-administration/networking.md#kubernetes-model)
) dalam _runtime_. Ini termasuk setiap implementasi yang berjalan sebagai [_plugin_ CNI](https://github.com/containernetworking/cni#3rd-party-plugins)
, seperti [Flannel](https://github.com/coreos/flannel#flannel)
, [Calico](http://docs.projectcalico.org/)
, [Romana](http://romana.io/)
, [Weave-net](https://www.weave.works/products/weave-net/)
.
CNI-Genie juga mendukung [menetapkan beberapa alamat IP ke sebuah Pod](https://github.com/Huawei-PaaS/CNI-Genie/blob/master/docs/multiple-ips/README.md#feature-2-extension-cni-genie-multiple-ip-address-per-pod)
, masing-masing dari _plugin_ CNI yang berbeda.
### cni-ipvlan-vpc-k8s
[cni-ipvlan-vpc-k8s](https://github.com/lyft/cni-ipvlan-vpc-k8s)
berisi satu set _plugin_ CNI dan IPAM untuk menyediakan kemudahan, host-lokal, latensi rendah, _throughput_ tinggi , dan tumpukan jaringan yang sesuai untuk Kubernetes dalam lingkungan Amazon Virtual Private Cloud (VPC) dengan memanfaatkan Amazon Elastic Network Interfaces (ENI) dan mengikat IP yang dikelola AWS ke Pod-Pod menggunakan _driver_ IPvlan _kernel_ Linux dalam mode L2.
Plugin ini dirancang untuk secara langsung mengkonfigurasi dan _deploy_ dalam VPC. Kubelet melakukan _booting_ dan kemudian mengkonfigurasi sendiri dan memperbanyak penggunaan IP mereka sesuai kebutuhan tanpa memerlukan kompleksitas yang sering direkomendasikan untuk mengelola jaringan _overlay_, BGP, menonaktifkan pemeriksaan sumber/tujuan, atau menyesuaikan tabel rute VPC untuk memberikan _subnet_ per _instance_ ke setiap _host_ (yang terbatas hingga 50-100 masukan per VPC). Singkatnya, cni-ipvlan-vpc-k8s secara signifikan mengurangi kompleksitas jaringan yang diperlukan untuk menggunakan Kubernetes yang berskala di dalam AWS.
### Contiv
[Contiv](https://github.com/contiv/netplugin)
menyediakan jaringan yang dapat dikonfigurasi (_native_ l3 menggunakan BGP, _overlay_ menggunakan vxlan, classic l2, atau Cisco-SDN / ACI) untuk berbagai kasus penggunaan. [Contiv](https://contivpp.io/)
semuanya open sourced.
### Contrail / Tungsten Fabric
[Contrail](http://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
, berdasarkan [Tungsten Fabric](https://tungsten.io/)
, adalah platform virtualisasi jaringan dan manajemen kebijakan _multi-cloud_ yang benar-benar terbuka. Contrail dan Tungsten Fabric terintegrasi dengan berbagai sistem orkestrasi seperti Kubernetes, OpenShift, OpenStack dan Mesos, dan menyediakan mode isolasi yang berbeda untuk mesin _virtual_, banyak kontainer / banyak Pod dan beban kerja _bare metal_.
### DANM
\[DANM\] ([https://github.com/nokia/danm](https://github.com/nokia/danm)
) adalah solusi jaringan untuk beban kerja telco yang berjalan di klaster Kubernetes. Dibangun dari komponen-komponen berikut:
* Plugin CNI yang mampu menyediakan antarmuka IPVLAN dengan fitur-fitur canggih
* Modul IPAM built-in dengan kemampuan mengelola dengan jumlah banyak, _cluster-wide_, _discontinous_ jaringan L3 dan menyediakan skema dinamis, statis, atau tidak ada permintaan skema IP
* Metaplugin CNI yang mampu melampirkan beberapa antarmuka jaringan ke kontainer, baik melalui CNI sendiri, atau mendelegasikan pekerjaan ke salah satu solusi CNI populer seperti SRI-OV, atau Flannel secara paralel
* Pengontrol Kubernetes yang mampu mengatur secara terpusat antarmuka VxLAN dan VLAN dari semua _host_ Kubernetes
* Pengontrol Kubernetes lain yang memperluas konsep _service discovery_ berbasis servis untuk bekerja di semua antarmuka jaringan Pod
Dengan _toolset_ ini, DANM dapat memberikan beberapa antarmuka jaringan yang terpisah, kemungkinan untuk menggunakan ujung belakang jaringan yang berbeda dan fitur IPAM canggih untuk Pod.
### Flannel
\[Flannel\] ([https://github.com/coreos/flannel#flannel](https://github.com/coreos/flannel#flannel)
) adalah jaringan overlay yang sangat sederhana yang memenuhi persyaratan Kubernetes. Banyak orang telah melaporkan kesuksesan dengan Flannel dan Kubernetes.
### Google Compute Engine (GCE)
Untuk skrip konfigurasi klaster Google Compute Engine, [perutean lanjutan](https://cloud.google.com/vpc/docs/routes)
digunakan untuk menetapkan setiap VM _subnet_ (standarnya adalah `/24` - 254 IP). Setiap lalu lintas yang terikat untuk _subnet_ itu akan dialihkan langsung ke VM oleh _fabric_ jaringan GCE. Ini adalah tambahan untuk alamat IP "utama" yang ditugaskan untuk VM, yang NAT'ed untuk akses internet keluar. Sebuah linux _bridge_ (disebut `cbr0`) dikonfigurasikan untuk ada pada subnet itu, dan diteruskan ke _flag_ `-bridge` milik docker.
Docker dimulai dengan:
DOCKER_OPTS="--bridge=cbr0 --iptables=false --ip-masq=false"
Jembatan ini dibuat oleh Kubelet (dikontrol oleh _flag_ `--network-plugin=kubenet`) sesuai dengan `.spec.podCIDR` yang dimiliki oleh Node.
Docker sekarang akan mengalokasikan IP dari blok `cbr-cidr`. Kontainer dapat menjangkau satu sama lain dan Node di atas jembatan `cbr0`. IP-IP tersebut semuanya dapat dirutekan dalam jaringan proyek GCE.
GCE sendiri tidak tahu apa-apa tentang IP ini, jadi tidak akan NAT untuk lalu lintas internet keluar. Untuk mencapai itu aturan iptables digunakan untuk menyamar (alias SNAT - untuk membuatnya seolah-olah paket berasal dari lalu lintas `Node` itu sendiri) yang terikat untuk IP di luar jaringan proyek GCE (10.0.0.0/8).
iptables -t nat -A POSTROUTING ! -d 10.0.0.0/8 -o eth0 -j MASQUERADE
Terakhir IP forwarding diaktifkan di kernel (sehingga kernel akan memproses paket untuk kontainer yang dijembatani):
sysctl net.ipv4.ip_forward=1
Hasil dari semua ini adalah bahwa semua Pod dapat saling menjangkau dan dapat keluar lalu lintas ke internet.
### Jaguar
[Jaguar](https://gitlab.com/sdnlab/jaguar)
adalah solusi open source untuk jaringan Kubernetes berdasarkan OpenDaylight. Jaguar menyediakan jaringan overlay menggunakan vxlan dan Jaguar CNIPlugin menyediakan satu alamat IP per Pod.
### Knitter
[Knitter](https://github.com/ZTE/Knitter/)
adalah solusi jaringan yang mendukung banyak jaringan di Kubernetes. Solusi ini menyediakan kemampuan manajemen penyewa dan manajemen jaringan. Knitter mencakup satu set solusi jaringan kontainer NFV ujung ke ujung selain beberapa pesawat jaringan, seperti menjaga alamat IP untuk aplikasi, migrasi alamat IP, dll.
### Kube-OVN
[Kube-OVN](https://github.com/alauda/kube-ovn)
adalah _fabric_ jaringan kubernetes berbasis OVN untuk _enterprises_. Dengan bantuan OVN/OVS, solusi ini menyediakan beberapa fitur jaringan _overlay_ canggih seperti _subnet_, QoS, alokasi IP statis, _mirroring traffic_, _gateway_, kebijakan jaringan berbasis _openflow_, dan proksi layanan.
### Kube-router
[Kube-router](https://github.com/cloudnativelabs/kube-router)
adalah solusi jaringan yang dibuat khusus untuk Kubernetes yang bertujuan untuk memberikan kinerja tinggi dan kesederhanaan operasional. Kube-router menyediakan Linux [LVS/IPVS](http://www.linuxvirtualserver.org/software/ipvs.html)
berbasis proksi layanan, solusi jaringan berbasis penerusan _pod-to-pod_ Linux _kernel_ tanpa _overlay_, dan penegak kebijakan jaringan berbasis _iptables/ipset_.
### L2 networks and linux bridging
Jika Anda memiliki jaringan L2 yang "bodoh", seperti saklar sederhana di _environment_ "bare-metal", kamu harus dapat melakukan sesuatu yang mirip dengan pengaturan GCE di atas. Perhatikan bahwa petunjuk ini hanya dicoba dengan sangat sederhana - sepertinya berhasil, tetapi belum diuji secara menyeluruh. Jika kamu menggunakan teknik ini dan telah menyempurnakan prosesnya, tolong beri tahu kami.
Ikuti bagian "With Linux Bridge devices" dari [tutorial yang sangat bagus ini](http://blog.oddbit.com/2014/08/11/four-ways-to-connect-a-docker/)
dari Lars Kellogg-Stedman.
### Multus (plugin Multi-Jaringan)
[Multus](https://github.com/Intel-Corp/multus-cni)
adalah plugin Multi CNI untuk mendukung fitur Banyak Jaringan di Kubernetes menggunakan objek jaringan berbasis CRD di Kubernetes.
Multus mendukung semua [plugin referensi](https://github.com/containernetworking/plugins)
(mis. [Flannel](https://github.com/containernetworking/plugins/tree/master/plugins/meta/flannel)
, [DHCP](https://github.com/containernetworking/plugins/tree/master/plugins/ipam/dhcp)
, \[Macvlan\]([https://github.com/containernetworking/plugins/tree/master/plugins/main](https://github.com/containernetworking/plugins/tree/master/plugins/main)
/ macvlan)) yang mengimplementasikan spesifikasi CNI dan plugin pihak ke-3 (mis. [Calico](https://github.com/projectcalico/cni-plugin)
, [Weave](https://github.com/weaveworks/weave)
, [Cilium](https://github.com/cilium/cilium)
, [Contiv](https://github.com/contiv/netplugin)
). Selain itu, Multus mendukung [SRIOV](https://github.com/hustcat/sriov-cni)
, [DPDK](https://github.com/Intel-Corp/sriov-cni)
, [OVS- DPDK & VPP](https://github.com/intel/vhost-user-net-plugin)
beban kerja di Kubernetes dengan aplikasi cloud asli dan aplikasi berbasis NFV di Kubernetes.
### NSX-T
[VMware NSX-T](https://docs.vmware.com/en/VMware-NSX-T/index.html)
adalah virtualisasi jaringan dan platform keamanan. NSX-T dapat menyediakan virtualisasi jaringan untuk lingkungan multi-cloud dan multi-hypervisor dan berfokus pada kerangka kerja dan arsitektur aplikasi yang muncul yang memiliki titik akhir dan tumpukan teknologi yang heterogen. Selain hypervisor vSphere, lingkungan ini termasuk hypervisor lainnya seperti KVM, wadah, dan bare metal.
[NSX-T Container Plug-in (NCP)](https://docs.vmware.com/en/VMware-NSX-T/2.0/nsxt_20_ncp_kubernetes.pdf)
menyediakan integrasi antara NSX-T dan pembuat wadah seperti Kubernetes, serta integrasi antara NSX-T dan platform CaaS / PaaS berbasis-kontainer seperti Pivotal Container Service (PKS) dan OpenShift.
### Nuage Networks VCS (Layanan Cloud Virtual)
[Nuage](http://www.nuagenetworks.net/)
menyediakan platform SDN (Software-Defined Networking) berbasis kebijakan yang sangat skalabel. Nuage menggunakan Open vSwitch _open source_ untuk data _plane_ bersama dengan SDN Controller yang kaya fitur yang dibangun pada standar terbuka.
Platform Nuage menggunakan _overlay_ untuk menyediakan jaringan berbasis kebijakan yang mulus antara Kubernetes Pod-Pod dan lingkungan non-Kubernetes (VM dan server _bare metal_). Model abstraksi kebijakan Nuage dirancang dengan mempertimbangkan aplikasi dan membuatnya mudah untuk mendeklarasikan kebijakan berbutir halus untuk aplikasi. Mesin analisis _real-time_ platform memungkinkan pemantauan visibilitas dan keamanan untuk aplikasi Kubernetes.
### OVN (Open Virtual Networking)
OVN adalah solusi virtualisasi jaringan opensource yang dikembangkan oleh komunitas Open vSwitch. Ini memungkinkan seseorang membuat switch logis, router logis, ACL stateful, load-balancers dll untuk membangun berbagai topologi jaringan virtual. Proyek ini memiliki plugin dan dokumentasi Kubernetes spesifik di [ovn-kubernetes](https://github.com/openvswitch/ovn-kubernetes)
.
### Project Calico
[Project Calico](http://docs.projectcalico.org/)
adalah penyedia jaringan wadah sumber terbuka dan mesin kebijakan jaringan.
Calico menyediakan solusi jaringan dan kebijakan kebijakan jaringan yang sangat berskala untuk menghubungkan Pod Kubernetes berdasarkan prinsip jaringan IP yang sama dengan internet, untuk Linux (open source) dan Windows (milik - tersedia dari [Tigera](https://www.tigera.io/essentials/)
). Calico dapat digunakan tanpa enkapsulasi atau _overlay_ untuk menyediakan jaringan pusat data skala tinggi yang berkinerja tinggi. Calico juga menyediakan kebijakan keamanan jaringan berbutir halus, berdasarkan niat untuk Pod Kubernetes melalui _firewall_ terdistribusi.
Calico juga dapat dijalankan dalam mode penegakan kebijakan bersama dengan solusi jaringan lain seperti Flannel, alias [kanal](https://github.com/tigera/canal)
, atau jaringan GCE, AWS atau Azure asli.
### Romana
[Romana](http://romana.io/)
adalah jaringan sumber terbuka dan solusi otomasi keamanan yang memungkinkan kamu menggunakan Kubernetes tanpa jaringan hamparan. Romana mendukung Kubernetes [Kebijakan Jaringan](https://kubernetes.io/id/docs/concepts/services-networking/network-policies/)
untuk memberikan isolasi di seluruh ruang nama jaringan.
### Weave Net dari Weaveworks
[Weave Net](https://www.weave.works/products/weave-net/)
adalah jaringan yang tangguh dan mudah digunakan untuk Kubernetes dan aplikasi yang dihostingnya. Weave Net berjalan sebagai [plug-in CNI](https://www.weave.works/docs/net/latest/cni-plugin/)
atau berdiri sendiri. Di kedua versi, itu tidak memerlukan konfigurasi atau kode tambahan untuk dijalankan, dan dalam kedua kasus, jaringan menyediakan satu alamat IP per Pod - seperti standar untuk Kubernetes.
Selanjutnya
-----------
Desain awal model jaringan dan alasannya, dan beberapa rencana masa depan dijelaskan secara lebih rinci dalam [dokumen desain jaringan](https://git.k8s.io/community/contributors/design-proposals/network/networking.md)
.
6 - Arsitektur Logging
======================
Log aplikasi dan sistem dapat membantu kamu untuk memahami apa yang terjadi di dalam klaster kamu. Log berguna untuk mengidentifikasi dan menyelesaikan masalah serta memonitor aktivitas klaster. Hampir semua aplikasi modern mempunyai sejenis mekanisme log sehingga hampir semua mesin kontainer didesain untuk mendukung suatu mekanisme _logging_. Metode _logging_ yang paling mudah untuk aplikasi dalam bentuk kontainer adalah menggunakan _standard output_ dan _standard error_.
Namun, fungsionalitas bawaan dari mesin kontainer atau _runtime_ biasanya tidak cukup memadai sebagai solusi log. Contohnya, jika sebuah kontainer gagal, sebuah pod dihapus, atau suatu _node_ mati, kamu biasanya tetap menginginkan untuk mengakses log dari aplikasimu. Oleh sebab itu, log sebaiknya berada pada penyimpanan dan _lifecyle_ yang terpisah dari node, pod, atau kontainer. Konsep ini dinamakan sebagai _logging_ pada level klaster. _Logging_ pada level klaster ini membutuhkan _backend_ yang terpisah untuk menyimpan, menganalisis, dan mengkueri log. Kubernetes tidak menyediakan solusi bawaan untuk penyimpanan data log, namun kamu dapat mengintegrasikan beragam solusi _logging_ yang telah ada ke dalam klaster Kubernetes kamu.
Arsitektur _logging_ pada level klaster yang akan dijelaskan berikut mengasumsikan bahwa sebuah _logging backend_ telah tersedia baik di dalam maupun di luar klastermu. Meskipun kamu tidak tertarik menggunakan _logging_ pada level klaster, penjelasan tentang bagaimana log disimpan dan ditangani pada node di bawah ini mungkin dapat berguna untukmu.
Hal dasar _logging_ pada Kubernetes
-----------------------------------
Pada bagian ini, kamu dapat melihat contoh tentang dasar _logging_ pada Kubernetes yang mengeluarkan data pada _standard output_. Demonstrasi berikut ini menggunakan sebuah [spesifikasi pod](https://kubernetes.io/examples/debug/counter-pod.yaml)
dengan kontainer yang akan menuliskan beberapa teks ke _standard output_ tiap detik.
[`debug/counter-pod.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/id/examples/debug/counter-pod.yaml)

apiVersion: v1
kind: Pod
metadata:
name: counter
spec:
containers:
- name: count
image: busybox
args: [/bin/sh, -c,\
'i=0; while true; do echo "$i: $(date)"; i=$((i+1)); sleep 1; done']
Untuk menjalankan pod ini, gunakan perintah berikut:
kubectl apply -f https://k8s.io/examples/debug/counter-pod.yaml
Keluarannya adalah:
pod/counter created
Untuk mengambil log, gunakan perintah `kubectl logs` sebagai berikut:
kubectl logs counter
Keluarannya adalah:
0: Mon Jan 1 00:00:00 UTC 2001
1: Mon Jan 1 00:00:01 UTC 2001
2: Mon Jan 1 00:00:02 UTC 2001
...
Kamu dapat menambahkan parameter `--previous` pada perintah `kubectl logs` untuk mengambil log dari kontainer sebelumnya yang gagal atau _crash_. Jika pod kamu memiliki banyak kontainer, kamu harus menspesifikasikan kontainer mana yang kamu ingin akses lognya dengan menambahkan nama kontainer pada perintah tersebut. Lihat [dokumentasi `kubectl logs`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#logs)
untuk informasi lebih lanjut.
Node-level _logging_
--------------------

Semua hal yang ditulis oleh aplikasi dalam kontainer ke `stdout` dan `stderr` akan ditangani dan diarahkan ke suatu tempat oleh mesin atau _engine_ kontainer. Contohnya,mesin kontainer Docker akan mengarahkan kedua aliran tersebut ke [suatu _logging driver_](https://docs.docker.com/engine/admin/logging/overview)
, yang akan dikonfigurasi pada Kubernetes untuk menuliskan ke dalam berkas dalam format json.
#### Catatan:
_Logging driver_ json dari Docker memperlakukan tiap baris sebagai pesan yang terpisah. Saat menggunakan _logging driver_ Docker, tidak ada dukungan untuk menangani pesan _multi-line_. Kamu harus menangani pesan _multi-line_ pada level agen log atau yang lebih tinggi.
Secara _default_, jika suatu kontainer _restart_, kubelet akan menjaga kontainer yang mati tersebut beserta lognya. Namun jika suatu pod dibuang dari _node_, maka semua hal dari kontainernya juga akan dibuang, termasuk lognya.
Hal lain yang perlu diperhatikan dalam _logging_ pada level _node_ adalah implementasi rotasi log, sehingga log tidak menghabiskan semua penyimpanan yang tersedia pada _node._ Kubernetes saat ini tidak bertanggung jawab dalam melakukan rotasi log, namun _deployment tool_ seharusnya memberikan solusi terhadap masalah tersebut. Contohnya, pada klaster Kubernetes, yang di _deployed_ menggunakan `kube-up.sh`, terdapat alat bernama [`logrotate`](https://linux.die.net/man/8/logrotate)
yang dikonfigurasi untuk berjalan tiap jamnya. Kamu juga dapat menggunakan _runtime_ kontainer untuk melakukan rotasi log otomatis, misalnya menggunakan `log-opt` Docker. Pada `kube-up.sh`, metode terakhir digunakan untuk COS _image_ pada GCP, sedangkan metode pertama digunakan untuk lingkungan lainnya. Pada kedua metode, secara _default_ akan dilakukan rotasi pada saat berkas log melewati 10MB.
Sebagai contoh, kamu dapat melihat informasi lebih rinci tentang bagaimana `kube-up.sh` mengatur _logging_ untuk COS _image_ pada GCP yang terkait dengan [_script_](https://github.com/kubernetes/kubernetes/blob/main/cluster/gce/gci/configure-helper.sh)
.
Saat kamu menjalankan perintah [`kubectl logs`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#logs)
seperti pada contoh tadi, kubelet di _node_ tersebut akan menangani permintaan untuk membaca langsung isi berkas log sebagai respon.
#### Catatan:
Saat ini, jika suatu sistem eksternal telah melakukan rotasi, hanya konten dari berkas log terbaru yang akan tersedia melalui perintah `kubectl logs`. Contoh, jika terdapat sebuah berkas 10MB, `logrotate` akan melakukan rotasi sehingga akan ada dua buah berkas, satu dengan ukuran 10MB, dan satu berkas lainnya yang kosong. Maka `kubectl logs` akan mengembalikan respon kosong.
### Komponen sistem log
Terdapat dua jenis komponen sistem: yaitu yang berjalan di dalam kontainer dan komponen lain yang tidak berjalan di dalam kontainer. Sebagai contoh:
* Kubernetes _scheduler_ dan kube-proxy berjalan di dalam kontainer.
* Kubelet dan _runtime_ kontainer, contohnya Docker, tidak berjalan di dalam kontainer.
Pada mesin yang menggunakan systemd, kubelet dan runtime _runtime_ menulis ke journald. Jika systemd tidak tersedia, keduanya akan menulis ke berkas `.log` pada folder `/var/log`. Komponen sistem di dalam kontainer akan selalu menuliskan ke folder `/var/log`, melewati mekanisme _default logging_. Mereka akan menggunakan _logging library_ [klog](https://github.com/kubernetes/klog)
. Kamu dapat menemukan konvensi tentang tingkat kegawatan _logging_ untuk komponen-komponen tersebut pada [dokumentasi _development logging_](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-instrumentation/logging.md)
.
Seperti halnya pada log kontainer, komponen sistem yang menuliskan log pada folder `/var/log` juga harus melakukan rotasi log. Pada klaster Kubernetes yang menggunakan `kube-up.sh`, log tersebut telah dikonfigurasi dan akan dirotasi oleh `logrotate` secara harian atau saat ukuran log melebihi 100MB.
Arsitektur klaster-level _logging_
----------------------------------
Meskipun Kubernetes tidak menyediakan solusi bawaan untuk _logging_ level klaster, ada beberapa pendekatan yang dapat kamu pertimbangkan. Berikut beberapa diantaranya:
* Menggunakan agen _logging_ pada level _node_ yang berjalan pada setiap _node_.
* Menggunakan kontainer _sidecar_ khusus untuk _logging_ aplikasi di dalam pod.
* Mengeluarkan log langsung ke _backend_ dari dalam aplikasi
### Menggunakan agen node-level _logging_

Kamu dapat mengimplementasikan klaster-level _logging_ dengan menggunakan agen yang berjalan pada setiap _node_. Agen _logging_ merupakan perangkat khusus yang akan mengekspos log atau mengeluarkan log ke _backend_. Umumnya agen _logging_ merupakan kontainer yang memiliki akses langsung ke direktori tempat berkas log berada dari semua kontainer aplikasi yang berjalan pada _node_ tersebut.
Karena agen _logging_ harus berjalan pada setiap _node_, umumnya dilakukan dengan menggunakan replika DaemonSet, _manifest_ pod, atau menjalankan proses khusus pada _node_. Namun dua cara terakhir sudah dideprekasi dan sangat tidak disarankan.
Menggunakan agen _logging_ pada level _node_ merupakan cara yang paling umum dan disarankan untuk klaster Kubernetes. Hal ini karena hanya dibutuhkan satu agen tiap node dan tidak membutuhkan perubahan apapun dari sisi aplikasi yang berjalan pada _node_. Namun, node-level _logging_ hanya dapat dilakukan untuk aplikasi yang menggunakan _standard output_ dan _standard error_.
Kubernetes tidak menspesifikasikan khusus suatu agen _logging_, namun ada dua agen _logging_ yang dimasukkan dalam rilis Kubernetes: [Stackdriver Logging](https://kubernetes.io/docs/user-guide/logging/stackdriver)
untuk digunakan pada Google Cloud Platform, dan [Elasticsearch](https://kubernetes.io/docs/user-guide/logging/elasticsearch)
. Kamu dapat melihat informasi dan instruksi pada masing-masing dokumentasi. Keduanya menggunakan [fluentd](http://www.fluentd.org/)
dengan konfigurasi kustom sebagai agen pada _node_.
### Menggunakan kontainer _sidecar_ dengan agen _logging_
Kamu dapat menggunakan kontainer _sidecar_ dengan salah satu cara berikut:
* Kontainer _sidecar_ mengeluarkan log aplikasi ke `stdout` miliknya sendiri.
* Kontainer _sidecar_ menjalankan agen _logging_ yang dikonfigurasi untuk mengambil log dari aplikasi kontainer.
#### Kontainer _streaming_ _sidecar_

Kamu dapat memanfaatkan kubelet dan agen _logging_ yang telah berjalan pada tiap _node_ dengan menggunakan kontainer _sidecar_. Kontainer _sidecar_ dapat membaca log dari sebuah berkas, _socket_ atau journald. Tiap kontainer _sidecar_ menuliskan log ke `stdout` atau `stderr` mereka sendiri.
Dengan menggunakan cara ini kamu dapat memisahkan aliran log dari bagian-bagian yang berbeda dari aplikasimu, yang beberapa mungkin tidak mendukung log ke `stdout` dan `stderr`. Perubahan logika aplikasimu dengan menggunakan cara ini cukup kecil, sehingga hampir tidak ada _overhead_. Selain itu, karena `stdout` dan `stderr` ditangani oleh kubelet, kamu juga dapat menggunakan alat bawaan seperti `kubectl logs`.
Sebagai contoh, sebuah pod berjalan pada satu kontainer tunggal, dan kontainer menuliskan ke dua berkas log yang berbeda, dengan dua format yang berbeda pula. Berikut ini _file_ konfigurasi untuk Pod:
[`admin/logging/two-files-counter-pod.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/id/examples/admin/logging/two-files-counter-pod.yaml)

apiVersion: v1
kind: Pod
metadata:
name: counter
spec:
containers:
- name: count
image: busybox
args:
- /bin/sh
- -c
- >
i=0;
while true;
do
echo "$i: $(date)" >> /var/log/1.log;
echo "$(date) INFO $i" >> /var/log/2.log;
i=$((i+1));
sleep 1;
done
volumeMounts:
- name: varlog
mountPath: /var/log
volumes:
- name: varlog
emptyDir: {}
Hal ini akan menyulitkan untuk mengeluarkan log dalam format yang berbeda pada aliran log yang sama, meskipun kamu dapat me-_redirect_ keduanya ke `stdout` dari kontainer. Sebagai gantinya, kamu dapat menggunakan dua buah kontainer _sidecar_. Tiap kontainer _sidecar_ dapat membaca suatu berkas log tertentu dari _shared volume_ kemudian mengarahkan log ke `stdout`\-nya sendiri.
Berikut _file_ konfigurasi untuk pod yang memiliki dua buah kontainer _sidecard_:
[`admin/logging/two-files-counter-pod-streaming-sidecar.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/id/examples/admin/logging/two-files-counter-pod-streaming-sidecar.yaml)

apiVersion: v1
kind: Pod
metadata:
name: counter
spec:
containers:
- name: count
image: busybox:1.28
args:
- /bin/sh
- -c
- >
i=0;
while true;
do
echo "$i: $(date)" >> /var/log/1.log;
echo "$(date) INFO $i" >> /var/log/2.log;
i=$((i+1));
sleep 1;
done
volumeMounts:
- name: varlog
mountPath: /var/log
- name: count-log-1
image: busybox:1.28
args: [/bin/sh, -c, 'tail -n+1 -F /var/log/1.log']
volumeMounts:
- name: varlog
mountPath: /var/log
- name: count-log-2
image: busybox:1.28
args: [/bin/sh, -c, 'tail -n+1 -F /var/log/2.log']
volumeMounts:
- name: varlog
mountPath: /var/log
volumes:
- name: varlog
emptyDir: {}
Saat kamu menjalankan pod ini, kamu dapat mengakses tiap aliran log secara terpisah dengan menjalankan perintah berikut:
kubectl logs counter count-log-1
0: Mon Jan 1 00:00:00 UTC 2001
1: Mon Jan 1 00:00:01 UTC 2001
2: Mon Jan 1 00:00:02 UTC 2001
...
kubectl logs counter count-log-2
Mon Jan 1 00:00:00 UTC 2001 INFO 0
Mon Jan 1 00:00:01 UTC 2001 INFO 1
Mon Jan 1 00:00:02 UTC 2001 INFO 2
...
Agen node-level yang terpasang di klastermu akan mengambil aliran log tersebut secara otomatis tanpa perlu melakukan konfigurasi tambahan. Bahkan jika kamu mau, kamu dapat mengonfigurasi agen untuk melakukan _parse_ baris log tergantung dari kontainer sumber awalnya.
Sedikit catatan, meskipun menggunakan memori dan CPU yang cukup rendah (sekitar beberapa milicore untuk CPU dan beberapa megabytes untuk memori), penulisan log ke _file_ kemudian mengalirkannya ke `stdout` dapat berakibat penggunaan disk yang lebih besar. Jika kamu memiliki aplikasi yang menuliskan ke _file_ tunggal, umumnya lebih baik menggunakan `/dev/stdout` sebagai tujuan daripada menggunakan pendekatan dengan kontainer _sidecar_.
Kontainer _sidecar_ juga dapat digunakan untuk melakukan rotasi berkas log yang tidak dapat dirotasi oleh aplikasi itu sendiri. Contoh dari pendekatan ini adalah sebuah kontainer kecil yang menjalankan rotasi log secara periodik. Namun, direkomendasikan untuk menggunakan `stdout` dan `stderr` secara langsung dan menyerahkan kebijakan rotasi dan retensi pada kubelet.
#### Kontainer _sidecar_ dengan agen _logging_

Jika agen node-level _logging_ tidak cukup fleksible untuk kebutuhanmu, kamu dapat membuat kontainer _sidecar_ dengan agen _logging_ yang terpisah, yang kamu konfigurasi spesifik untuk berjalan dengan aplikasimu.
#### Catatan:
Menggunakan agen _logging_ di dalam kontainer _sidecar_ dapat berakibat penggunaan _resource_ yang signifikan. Selain itu, kamu tidak dapat mengakses log itu dengan menggunakan perintah `kubectl logs`, karena mereka tidak dikontrol oleh kubelet.
Sebagai contoh, kamu dapat menggunakan [Stackdriver](https://kubernetes.io/docs/tasks/debug-application-cluster/logging-stackdriver/)
, yang menggunakan fluentd sebagai agen _logging_. Berikut ini dua _file_ konfigurasi yang dapat kamu pakai untuk mengimplementasikan cara ini. _File_ yang pertama berisi sebuah [ConfigMap](https://kubernetes.io/id/docs/tasks/configure-pod-container/configure-pod-configmap/)
untuk mengonfigurasi fluentd.
[`admin/logging/fluentd-sidecar-config.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/id/examples/admin/logging/fluentd-sidecar-config.yaml)

apiVersion: v1
kind: ConfigMap
metadata:
name: fluentd-config
data:
fluentd.conf: |
type tail
format none
path /var/log/1.log
pos_file /var/log/1.log.pos
tag count.format1
type tail
format none
path /var/log/2.log
pos_file /var/log/2.log.pos
tag count.format2
type google_cloud
#### Catatan:
Konfigurasi fluentd berada diluar cakupan artikel ini. Untuk informasi lebih lanjut tentang cara mengonfigurasi fluentd, silakan lihat [dokumentasi resmi fluentd](http://docs.fluentd.org/)
.
_File_ yang kedua mendeskripsikan sebuah pod yang memiliki kontainer _sidecar_ yang menjalankan fluentd. Pod ini melakukan _mount_ sebuah volume yang akan digunakan fluentd untuk mengambil data konfigurasinya.
[`admin/logging/two-files-counter-pod-agent-sidecar.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/id/examples/admin/logging/two-files-counter-pod-agent-sidecar.yaml)

apiVersion: v1
kind: Pod
metadata:
name: counter
spec:
containers:
- name: count
image: busybox
args:
- /bin/sh
- -c
- >
i=0;
while true;
do
echo "$i: $(date)" >> /var/log/1.log;
echo "$(date) INFO $i" >> /var/log/2.log;
i=$((i+1));
sleep 1;
done
volumeMounts:
- name: varlog
mountPath: /var/log
- name: count-agent
image: registry.k8s.io/fluentd-gcp:1.30
env:
- name: FLUENTD_ARGS
value: -c /etc/fluentd-config/fluentd.conf
volumeMounts:
- name: varlog
mountPath: /var/log
- name: config-volume
mountPath: /etc/fluentd-config
volumes:
- name: varlog
emptyDir: {}
- name: config-volume
configMap:
name: fluentd-config
Setelah beberapa saat, kamu akan mendapati pesan log pada _interface_ Stackdriver.
Ingat, ini hanya contoh saja dan kamu dapat mengganti fluentd dengan agen _logging_ lainnya, yang dapat membaca sumber apa saja dari dalam kontainer aplikasi.
### Mengekspos log langsung dari aplikasi

Kamu dapat mengimplementasikan klaster-level _logging_ dengan mengekspos atau mengeluarkan log langsung dari tiap aplikasi; namun cara implementasi mekanisme _logging_ tersebut diluar cakupan dari Kubernetes.
7 - Metrik untuk Komponen Sistem Kubernetes
===========================================
Metrik dari komponen sistem dapat memberikan gambaran yang lebih baik tentang apa yang sedang terjadi di dalam sistem. Metrik sangat berguna untuk membuat dasbor (_dashboard_) dan peringatan (_alert_).
Komponen Kubernetes mengekspos metrik dalam [format Prometheus](https://prometheus.io/docs/instrumenting/exposition_formats/)
. Format ini berupa teks biasa yang terstruktur, dirancang agar orang dan mesin dapat membacanya.
Metrik-metrik dalam Kubernetes
------------------------------
Dalam kebanyakan kasus, metrik tersedia pada _endpoint_ `/metrics` dari server HTTP. Untuk komponen yang tidak mengekspos _endpoint_ secara bawaan, _endpoint_ tersebut dapat diaktifkan dengan menggunakan opsi `--bind-address`.
Contoh-contoh untuk komponen tersebut adalah:
* [kube-controller-manager](https://kubernetes.io/id/docs/reference/generated/kube-controller-manager/ "Komponen control plane yang menjalankan pengontrol.")
* [kube-proxy](https://kubernetes.io/id/docs/reference/command-line-tools-reference/kube-proxy/ "kube-proxy merupakan proksi jaringan yang berjalan pada setiap node di dalam klaster.")
* [kube-apiserver](https://kubernetes.io/id/docs/reference/generated/kube-apiserver/ "Komponen control plane yang mengekspos API Kubernetes. Merupakan front-end dari control plane Kubernetes.")
* [kube-scheduler](https://kubernetes.io/id/docs/reference/generated/kube-scheduler/ "Komponen control plane yang bertugas mengamati Pod baru yang belum ditempatkan di node manapun dan kemudian memilihkan node di mana Pod baru tersebut akan dijalankan.")
* [kubelet](https://kubernetes.io/id/docs/reference/generated/kubelet "Agen yang dijalankan pada setiap node di klaster yang bertugas untuk memastikan kontainer dijalankan di dalam Pod.")
Di dalam lingkungan produksi, kamu mungkin ingin mengonfigurasi [Server Prometheus](https://prometheus.io/)
atau pengambil metrik (_metrics scraper_) lainnya untuk mengumpulkan metrik-metrik ini secara berkala dan membuatnya tersedia dalam semacam pangkalan data deret waktu (_time series database_).
Perlu dicatat bahwa [kubelet](https://kubernetes.io/id/docs/reference/generated/kubelet "Agen yang dijalankan pada setiap node di klaster yang bertugas untuk memastikan kontainer dijalankan di dalam Pod.")
juga mengekspos metrik pada _endpoint-endpoint_ seperti `/metrics/cadvisor`, `/metrics/resource` dan `/metrics/probes`. Metrik-metrik tersebut tidak memiliki siklus hidup yang sama.
Jika klastermu menggunakan [RBAC](https://kubernetes.io/id/docs/reference/access-authn-authz/rbac/ "Mengelola keputusan otorisasi, memungkinkan admin untuk mengonfigurasi kebijakan akses secara dinamis melalui API Kubernetes.")
, maka membaca metrik memerlukan otorisasi melalui _user_, _group_, atau ServiceAccount dengan ClusterRole yang memperbolehkan untuk mengakses `/metrics`.
Sebagai contoh:
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: prometheus
rules:
- nonResourceURLs:
- "/metrics"
verbs:
- get
Siklus hidup metrik
-------------------
Metrik alfa (_alpha_) → Metrik stabil → Metrik usang (_deprecated_) → Metrik tersembunyi → Metrik terhapus
Metrik alfa tidak memiliki jaminan stabilitas. Metrik ini dapat dimodifikasi atau dihapus kapan saja.
Metrik stabil dijamin tidak akan mengalami perubahan. Hal ini berarti:
* Metrik stabil tanpa penanda usang (_deprecated signature_) tidak akan dihapus ataupun diganti namanya
* Jenis metrik stabil tidak akan dimodifikasi
Metrik usang dijadwalkan untuk dihapus, tetapi masih tersedia untuk digunakan. Metrik ini mencakup anotasi versi di mana metrik ini dianggap menjadi usang.
Sebagai contoh:
* Sebelum menjadi usang
# HELP some_counter this counts things
# TYPE some_counter counter
some_counter 0
* Setelah menjadi usang
# HELP some_counter (Deprecated since 1.15.0) this counts things
# TYPE some_counter counter
some_counter 0
Metrik tersembunyi tidak lagi dipublikasikan untuk pengambilan metrik (_scraping_), tetapi masih tersedia untuk digunakan. Untuk menggunakan metrik tersembunyi, lihat bagian [Menampilkan metrik tersembunyi](https://kubernetes.io/id/docs/concepts/cluster-administration/_print/#menampilkan-metrik-tersembunyi)
.
Metrik yang terhapus tidak lagi dipublikasikan dan tidak dapat digunakan lagi.
Menampilkan metrik tersembunyi
------------------------------
Seperti yang dijelaskan di atas, admin dapat mengaktifkan metrik tersembunyi melalui opsi baris perintah pada biner (program) tertentu. Ini dimaksudkan untuk digunakan sebagai jalan keluar bagi admin jika mereka melewatkan migrasi metrik usang dalam rilis terakhir.
Opsi `show-hidden-metrics-for-version` menerima input versi yang kamu inginkan untuk menampilkan metrik usang dalam rilis tersebut. Versi tersebut dinyatakan sebagai x.y, di mana x adalah versi mayor, y adalah versi minor. Versi _patch_ tidak diperlukan meskipun metrik dapat menjadi usang dalam rilis _patch_, alasannya adalah kebijakan penandaan metrik usang dijalankan terhadap rilis minor.
Opsi tersebut hanya dapat menerima input versi minor sebelumnya sebagai nilai. Semua metrik yang disembunyikan di versi sebelumnya akan dikeluarkan jika admin mengatur versi sebelumnya ke `show-hidden-metrics-for-version`. Versi yang terlalu lama tidak diperbolehkan karena melanggar kebijakan untuk metrik usang.
Ambil metrik `A` sebagai contoh, di sini diasumsikan bahwa `A` sudah menjadi usang di versi 1.n. Berdasarkan kebijakan metrik usang, kita dapat mencapai kesimpulan berikut:
* Pada rilis `1.n`, metrik menjadi usang, dan dapat dikeluarkan secara bawaan.
* Pada rilis `1.n+1`, metrik disembunyikan secara bawaan dan dapat dikeluarkan dengan baris perintah `show-hidden-metrics-for-version=1.n`.
* Pada rilis `1.n+2`, metrik harus dihapus dari _codebase_. Tidak ada jalan keluar lagi.
Jika kamu meningkatkan versi dari rilis `1.12` ke `1.13`, tetapi masih bergantung pada metrik `A` yang usang di `1.12`, kamu harus mengatur metrik tersembunyi melalui baris perintah: `--show-hidden-metrics = 1.12` dan ingatlah untuk menghapus ketergantungan terhadap metrik ini sebelum meningkatkan versi rilis ke `1.14`.
Menonaktifkan metrik akselerator
--------------------------------
kubelet mengumpulkan metrik akselerator melalui cAdvisor. Untuk mengumpulkan metrik ini, untuk akselerator seperti GPU NVIDIA, kubelet membuka koneksi dengan _driver_ GPU. Ini berarti untuk melakukan perubahan infrastruktur (misalnya, pemutakhiran _driver_), administrator klaster perlu menghentikan agen kubelet.
Pengumpulkan metrik akselerator sekarang menjadi tanggung jawab vendor dibandingkan kubelet. Vendor harus menyediakan sebuah kontainer untuk mengumpulkan metrik dan mengeksposnya ke layanan metrik (misalnya, Prometheus).
[Gerbang fitur `DisableAcceleratorUsageMetrics`](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/)
menonaktifkan metrik yang dikumpulkan oleh kubelet, dengan [lini masa (_timeline_) untuk mengaktifkan fitur ini secara bawaan](https://github.com/kubernetes/enhancements/tree/411e51027db842355bd489691af897afc1a41a5e/keps/sig-node/1867-disable-accelerator-usage-metrics#graduation-criteria)
.
Metrik komponen
---------------
### Metrik kube-controller-manager
Metrik _controller manager_ memberikan gambaran penting tentang kinerja dan kesehatan _controller manager_. Metrik ini mencakup metrik _runtime_ bahasa Go yang umum seperti jumlah go\_routine dan metrik khusus pengontrol seperti latensi permintaan etcd atau latensi API Cloudprovider (AWS, GCE, OpenStack) yang dapat digunakan untuk mengukur kesehatan klaster.
Mulai dari Kubernetes 1.7, metrik Cloudprovider yang detail tersedia untuk operasi penyimpanan untuk GCE, AWS, Vsphere, dan OpenStack. Metrik ini dapat digunakan untuk memantau kesehatan operasi _persistent volume_.
Misalnya, untuk GCE metrik-metrik berikut ini dipanggil:
cloudprovider_gce_api_request_duration_seconds { request = "instance_list"}
cloudprovider_gce_api_request_duration_seconds { request = "disk_insert"}
cloudprovider_gce_api_request_duration_seconds { request = "disk_delete"}
cloudprovider_gce_api_request_duration_seconds { request = "attach_disk"}
cloudprovider_gce_api_request_duration_seconds { request = "detach_disk"}
cloudprovider_gce_api_request_duration_seconds { request = "list_disk"}
### Metrik kube-scheduler
FEATURE STATE: `Kubernetes v1.20 [alpha]`
Penjadwal mengekspos metrik opsional yang melaporkan sumber daya yang diminta dan limit yang diinginkan dari semua pod yang berjalan. Metrik ini dapat digunakan untuk membangun dasbor perencanaan kapasitas, mengevaluasi limit penjadwalan yang digunakan saat ini atau secara historis, dengan cepat mengidentifikasi beban kerja yang tidak dapat dijadwalkan karena kurangnya sumber daya, dan membandingkan permintaan sumber daya oleh pod dengan penggunaannya yang aktual.
kube-scheduler mengidentifikasi [permintaan dan limit](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/)
sumber daya yang dikonfigurasi untuk setiap Pod; jika permintaan atau limit bukan nol, kube-scheduler akan melaporkan deret waktu (_timeseries_) metrik. Deret waktu diberi label dengan:
* namespace
* nama pod
* node di mana pod dijadwalkan atau _string_ kosong jika belum dijadwalkan
* prioritas
* penjadwal yang ditugaskan untuk pod itu
* nama dari sumber daya (misalnya, `cpu`)
* satuan dari sumber daya jika diketahui (misalnya, `cores`)
Setelah pod selesai (memiliki `restartPolicy` `Never` atau `OnFailure` dan berada dalam fase pod `Succeeded` atau `Failed`, atau telah dihapus dan semua kontainer dalam keadaan Terminated) deret metrik tidak lagi dilaporkan karena penjadwal sekarang sudah dibebaskan untuk menjadwalkan pod lain untuk dijalankan. Metrik yang dibahas pada bagian ini dikenal sebagai `kube_pod_resource_request` dan `kube_pod_resource_limit`.
Metrik diekspos melalui _endpoint_ HTTP `/metrics/resources` dan memerlukan otorisasi yang sama seperti endpoint `/metrics` pada penjadwal. Kamu harus menggunakan opsi `--show-hidden-metrics-for-version=1.20` untuk mengekspos metrik-metrik stabilitas alfa ini.
Selanjutnya
-----------
* Baca tentang [format teks Prometheus](https://github.com/prometheus/docs/blob/main/docs/instrumenting/exposition_formats.md#text-based-format)
untuk berbagai metrik
* Baca tentang [kebijakan _deprecation_ Kubernetes](https://kubernetes.io/docs/reference/using-api/deprecation-policy/#deprecating-a-feature-or-behavior)
8 - Konfigurasi Garbage Collection pada kubelet
===============================================
_Garbage collection_ merupakan fitur kubelet yang sangat bermanfaat, yang akan membersihkan _image-image_ dan juga kontainer-kontainer yang tidak lagi digunakan. Kubelet akan melakukan _garbage collection_ untuk kontainer setiap satu menit dan _garbage collection_ untuk _image_ setiap lima menit.
Perangkat _garbage collection_ eksternal tidak direkomendasikan karena perangkat tersebut berpotensi merusak perilaku kubelet dengan menghilangkan kontainer-kontainer yang sebenarnya masih diperlukan.
_Garbage Collection_ untuk _Image_
----------------------------------
Kubernetes mengelola _lifecycle_ untuk seluruh _image_ melalui _imageManager_, dengan bantuan cadvisor.
_Policy_ untuk melakukan _garbage collection_ memperhatikan dua hal: `HighThresholdPercent` dan `LowThresholdPercent`. Penggunaan disk yang melewati batas atas (_high threshold_) akan men-_trigger_ _garbage collection_. _Garbage collection_ akan mulai menghapus dari _image-image_ yang paling jarang digunakan (_least recently used_) sampai menemui batas bawah (_low threshold_) kembali.
_Garbage Collection_ untuk Kontainer
------------------------------------
_Policy_ untuk melakukan _garbage collection_ pada kontainer memperhatikan tiga variabel yang ditentukan oleh pengguna (_user-defined_). `MinAge` merupakan umur minimal dimana suatu kontainer dapat terkena _garbage collection_. `MaxPerPodContainer` merupakan jumlah maksimum yang diperbolehkan untuk setiap pod (UID, container name) _pair_ memiliki kontainer-kontainer yang sudah mati (_dead containers_). `MaxContainers` merupakan jumlah maksimal total dari seluruh kontainer yang sudah mati. Semua variabel ini dapat dinonaktifkan secara individual, dengan mengatur `MinAge` ke angka nol serta mengatur `MaxPerPodContainer` dan `MaxContainers` ke angka di bawah nol.
Kubelet akan mengambil tindakan untuk kontainer-kontainer yang tidak dikenal, sudah dihapus, atau diluar batasan-batasan yang diatur sebelumnya melalui _flag_. Kontainer-kontainer yang paling lama (tertua) biasanya akan dihapus terlebih dahulu. `MaxPerPodContainer` dan `MaxContainer` berpotensi mengalami konflik satu sama lain pada situasi saat menjaga jumlah maksimal kontainer per pod (`MaxPerPodContainer`) akan melebihi jumlah kontainer mati (_dead containers_) yang diperbolehkan (`MaxContainers`). `MaxPerPodContainer` dapat diatur sedemikian rupa dalam situasi ini: Seburuk-buruhknya dengan melakukan _downgrade_ `MaxPerPodContainer` ke angka 1 dan melakukan _evict_ kontainer-kontainer yang paling lama. Selain itu, kontainer-kontainer milik Pod yang telah dihapus akan dihilangkan saat umur mereka telah melebihi `MinAge`.
Kontainer-kontainer yang tidak dikelola oleh kubelet akan terbebas dari _garbage collection_.
Konfigurasi Pengguna
--------------------
Para pengguna dapat mengatur _threshold-threshold_ untuk melakukan _tuning_ pada _garbage collection image_ melalui _flag-flag_ kubelet sebagai berikut:
1. `image-gc-high-threshold`, persentase dari penggunaan disk yang men-_trigger_ proses _garbage collection_ untuk _image_. _Default_\-nya adalah 85%.
2. `image-gc-low-threshold`, persentase dari penggunaan disk dimana _garbage collection_ berusaha menghapus _image_. _Default_\-nya adalah 80%.
Kami juga memperbolehkan para pengguna untuk menyesuaikan _policy garbage collection_ melalui _flag-flag_ kubelet sebagai berikut:
1. `minimum-container-ttl-duration`, umur minimal untuk setiap kontainer yang sudah selesai (_finished_) sebelum terkena _garbage collection_. _Default_\-nya adalah 0 menit, yang berarti setiap kontainer yang telah selesai akan terkena _garbage collection_.
2. `maximum-dead-containers-per-container`, jumlah maksimal dari kontainer-kontainer lama yang diperbolehkan ada secara global. _Default_\-nya adalah -1, yang berarti tidak ada batasannya untuk global.
Kontainer-kontainer dapat berpotensi terkena _garbage collection_ sebelum kegunaannya telah usang. Kontainer-kontainer ini memliki log dan data lainnya yang bisa saja berguna saat _troubleshoot_. Sangat direkomendasikan untuk menetapkan angka yang cukup besar pada `maximum-dead-containers-per-container`, untuk memperbolehkan paling tidak 1 kontainer mati untuk dijaga (_retained_) per jumlah kontainer yang diharapkan. Angka yang lebih besar untuk `maximum-dead-containers` juga direkomendasikan untuk alasan serupa. Lihat [isu ini](https://github.com/kubernetes/kubernetes/issues/13287)
untuk penjelasan lebih lanjut.
_Deprecation_
-------------
Beberapa fitur _Garbage Collection_ pada kubelet di laman ini akan digantikan oleh fitur _eviction_ nantinya, termasuk:
| _Flag Existing_ | _Flag_ Baru | Alasan |
| --- | --- | --- |
| `--image-gc-high-threshold` | `--eviction-hard` atau `--eviction-soft` | sinyal _eviction_ yang ada (_existing_) dapat men-_trigger_ _garbage collection_ |
| `--image-gc-low-threshold` | `--eviction-minimum-reclaim` | hal serupa dapat diperoleh dengan _eviction reclaim_ |
| `--maximum-dead-containers` | | _deprecated_ saat log yang telah usang tersimpan di luar konteks kontainer |
| `--maximum-dead-containers-per-container` | | _deprecated_ saat log yang telah usang tersimpan di luar konteks kontainer |
| `--minimum-container-ttl-duration` | | _deprecated_ saat log yang telah usang tersimpan di luar konteks kontainer |
| `--low-diskspace-threshold-mb` | `--eviction-hard` atau `eviction-soft` | _eviction_ memberi generalisasi _threshold_ disk untuk _resource-resource_ lainnya |
| `--outofdisk-transition-frequency` | `--eviction-pressure-transition-period` | _eviction_ memberi generalisasi transisi tekanan _disk_ (_disk pressure_)untuk _resource-resource_ lainnya |
Selanjutnya
-----------
Lihat [Konfigurasi untuk Menangani Kehabisan _Resource_](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/)
untuk penjelasan lebih lanjut.
9 - Berbagai Proxy di Kubernetes
================================
Laman ini menjelaskan berbagai _proxy_ yang ada di dalam Kubernetes.
Berbagai Jenis _Proxy_
----------------------
Ada beberapa jenis _proxy_ yang akan kamu temui saat menggunakan Kubernetes:
1. [kubectl proxy](https://kubernetes.io/id/docs/tasks/access-application-cluster/access-cluster/#directly-accessing-the-rest-api)
:
* dijalankan pada _desktop_ pengguna atau di dalam sebuah Pod
* melakukan _proxy_ dari alamat localhost ke apiserver Kubernetes
* dari klien menuju _proxy_ menggunakan HTTP
* dari _proxy_ menuju apiserver menggunakan HTTPS
* mencari lokasi apiserver
* menambahkan _header_ autentikasi
2. [apiserver proxy](https://kubernetes.io/id/docs/tasks/access-application-cluster/access-cluster/#discovering-builtin-services)
:
* merupakan sebuah _bastion_ yang ada di dalam apiserver
* menghubungkan pengguna di luar klaster ke alamat-alamat IP di dalam klaster yang tidak bisa terjangkau
* dijalankan bersama _process-process_ apiserver
* dari klien menuju _proxy_ menggunakan HTTPS (atau http jika dikonfigurasi pada apiserver)
* dari _proxy_ menuju target menggunakan HTTP atau HTTPS, tergantung pilihan yang diambil oleh _proxy_ melalui informasi yang ada
* dapat digunakan untuk menghubungi Node, Pod, atau Service
* melakukan _load balancing_ saat digunakan untuk menjangkau sebuah Service
3. [kube proxy](https://kubernetes.io/id/docs/concepts/services-networking/service/#ips-and-vips)
:
* dijalankan pada setiap Node
* melakukan _proxy_ untuk UDP, TCP dan SCTP
* tidak mengerti HTTP
* menyediakan _load balancing_
* hanya digunakan untuk menjangkau berbagai Service
4. Sebuah _Proxy/Load-balancer_ di depan satu atau banyak apiserver:
* keberadaan dan implementasinya bervariasi tergantung pada klaster (contohnya nginx)
* ada di antara seluruh klien dan satu/banyak apiserver
* jika ada beberapa apiserver, berfungsi sebagai _load balancer_
5. _Cloud Load Balancer_ pada servis eksternal:
* disediakan oleh beberapa penyedia layanan cloud, seperti AWS ELB, Google Cloud Load Balancer
* dibuat secara otomatis ketika Service dari Kubernetes dengan tipe `LoadBalancer`
* biasanya hanya tersedia untuk UDP/TCP
* _support_ untuk SCTP tergantung pada _load balancer_ yang diimplementasikan oleh penyedia cloud
* implementasi bervariasi tergantung pada penyedia cloud
Pengguna Kubernetes biasanya hanya cukup perlu tahu tentang kubectl _proxy_ dan apiserver _proxy_. Untuk _proxy-proxy_ lain di luar ini, admin klaster biasanya akan memastikan konfigurasinya dengan benar.
Melakukan _request redirect_
----------------------------
_Proxy_ telah menggantikan fungsi _redirect_. _Redirect_ telah terdeprekasi.
10 - Metrik controller manager
==============================
Metrik _controller manager_ memberikan informasi penting tentang kinerja dan kesehatan dari _controller manager_.
Tentang metrik _controller manager_
-----------------------------------
Metrik _controller manager_ ini berfungsi untuk memberikan informasi penting tentang kinerja dan kesehatan dari _controller manager_. Metrik ini juga berisi tentang metrik umum dari _runtime_ bahasa pemrograman Go seperti jumlah _go\_routine_ dan metrik spesifik dari _controller_ seperti latensi dari etcd _request_ atau latensi API dari penyedia layanan _cloud_ (AWS, GCE, OpenStack) yang dapat digunakan untuk mengukur kesehatan dari klaster.
Mulai dari Kubernetes 1.7, metrik yang lebih mendetil tentang operasi penyimpanan dari penyedia layanan _cloud_ juga telah tersedia. Metrik-metrik ini dapat digunakan untuk memonitor kesehatan dari operasi _persistent volume_.
Berikut merupakan contoh nama metrik yang disediakan GCE:
cloudprovider_gce_api_request_duration_seconds { request = "instance_list"}
cloudprovider_gce_api_request_duration_seconds { request = "disk_insert"}
cloudprovider_gce_api_request_duration_seconds { request = "disk_delete"}
cloudprovider_gce_api_request_duration_seconds { request = "attach_disk"}
cloudprovider_gce_api_request_duration_seconds { request = "detach_disk"}
cloudprovider_gce_api_request_duration_seconds { request = "list_disk"}
Konfigurasi
-----------
Pada sebuah klaster, informasi metrik _controller manager_ dapat diakses melalui `http://localhost:10252/metrics` dari _host_ tempat _controller manager_ dijalankan.
Metrik ini dikeluarkan dalam bentuk [format prometheus](https://prometheus.io/docs/instrumenting/exposition_formats/)
serta mudah untuk dibaca manusia.
Pada _environment_ produksi, kamu mungkin juga ingin mengonfigurasi prometheus atau pengumpul metrik lainnya untuk mengumpulkan metrik-metrik ini secara berkala dalam bentuk basis data _time series_.
11 - Instalasi Add-ons
======================
_Add-ons_ berfungsi untuk menambah serta memperluas fungsionalitas dari Kubernetes.
Laman ini akan menjabarkan beberapa _add-ons_ yang tersedia serta tautan instruksi bagaimana cara instalasi masing-masing _add-ons_.
_Add-ons_ pada setiap bagian akan diurutkan secara alfabet - pengurutan ini tidak dilakukan berdasarkan status preferensi atau keunggulan.
Jaringan dan _Policy_ Jaringan
------------------------------
* [ACI](https://www.github.com/noironetworks/aci-containers)
menyediakan integrasi jaringan kontainer dan keamanan jaringan dengan Cisco ACI.
* [Calico](https://docs.projectcalico.org/latest/getting-started/kubernetes/)
merupakan penyedia jaringan L3 yang aman dan _policy_ jaringan.
* [Canal](https://projectcalico.docs.tigera.io/getting-started/kubernetes/flannel/flannel)
menggabungkan Flannel dan Calico, menyediakan jaringan serta _policy_ jaringan.
* [Cilium](https://github.com/cilium/cilium)
merupakan _plugin_ jaringan L3 dan _policy_ jaringan yang dapat menjalankan _policy_ HTTP/API/L7 secara transparan. Mendukung mode _routing_ maupun _overlay/encapsulation_.
* [CNI-Genie](https://github.com/cni-genie/CNI-Genie)
memungkinkan Kubernetes agar dapat terkoneksi dengan beragam _plugin_ CNI, seperti Calico, Canal, Flannel, Romana, atau Weave dengan mulus.
* [Contiv](https://contivpp.io/)
menyediakan jaringan yang dapat dikonfigurasi (_native_ L3 menggunakan BGP, _overlay_ menggunakan vxlan, klasik L2, dan Cisco-SDN/ACI) untuk berbagai penggunaan serta _policy framework_ yang kaya dan beragam. Proyek Contiv merupakan proyek [open source](https://github.com/contiv)
. Laman [instalasi](https://github.com/contiv/install)
ini akan menjabarkan cara instalasi, baik untuk klaster dengan kubeadm maupun non-kubeadm.
* [Contrail](http://www.juniper.net/us/en/products-services/sdn/contrail/contrail-networking/)
, yang berbasis dari [Tungsten Fabric](https://tungsten.io/)
, merupakan sebuah proyek _open source_ yang menyediakan virtualisasi jaringan _multi-cloud_ serta platform manajemen _policy_. Contrail dan Tungsten Fabric terintegrasi dengan sistem orkestrasi lainnya seperti Kubernetes, OpenShift, OpenStack dan Mesos, serta menyediakan mode isolasi untuk mesin virtual (VM), kontainer/pod dan _bare metal_.
* [Flannel](https://github.com/flannel-io/flannel#deploying-flannel-manually)
merupakan penyedia jaringan _overlay_ yang dapat digunakan pada Kubernetes.
* [Knitter](https://github.com/ZTE/Knitter/)
merupakan solusi jaringan yang mendukung multipel jaringan pada Kubernetes.
* [Multus](https://github.com/k8snetworkplumbingwg/multus-cni)
merupakan sebuah multi _plugin_ agar Kubernetes mendukung multipel jaringan secara bersamaan sehingga dapat menggunakan semua _plugin_ CNI (contoh: Calico, Cilium, Contiv, Flannel), ditambah pula dengan SRIOV, DPDK, OVS-DPDK dan VPP pada _workload_ Kubernetes.
* [NSX-T](https://docs.vmware.com/en/VMware-NSX-T-Data-Center/index.html)
Container Plug-in (NCP) menyediakan integrasi antara VMware NSX-T dan orkestrator kontainer seperti Kubernetes, termasuk juga integrasi antara NSX-T dan platform CaaS/PaaS berbasis kontainer seperti _Pivotal Container Service_ (PKS) dan OpenShift.
* [Nuage](https://github.com/nuagenetworks/nuage-kubernetes/blob/v5.1.1-1/docs/kubernetes-1-installation.rst)
merupakan platform SDN yang menyediakan _policy-based_ jaringan antara Kubernetes Pods dan non-Kubernetes _environment_ dengan _monitoring_ visibilitas dan keamanan.
* [Romana](http://romana.io/)
merupakan solusi jaringan _Layer_ 3 untuk jaringan pod yang juga mendukung [_NetworkPolicy_ API](https://kubernetes.io/id/docs/concepts/services-networking/network-policies/)
. Instalasi Kubeadm _add-on_ ini tersedia [di sini](https://github.com/romana/romana/tree/master/containerize)
.
* [Weave Net](https://www.weave.works/docs/net/latest/kube-addon/)
menyediakan jaringan serta _policy_ jaringan, yang akan membawa kedua sisi dari partisi jaringan, serta tidak membutuhkan basis data eksternal.
_Service Discovery_
-------------------
* [CoreDNS](https://coredns.io/)
merupakan server DNS yang fleksibel, mudah diperluas yang dapat [diinstal](https://github.com/coredns/helm)
sebagai _in-cluster_ DNS untuk pod.
Visualisasi & Kontrol
---------------------
* [Dashboard](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
merupakan antarmuka web dasbor untuk Kubernetes.
_Add-ons_ Terdeprekasi
----------------------
Ada beberapa _add-on_ lain yang didokumentasikan pada direktori deprekasi [_cluster/addons_](https://git.k8s.io/kubernetes/cluster/addons)
.
_Add-on_ lain yang dipelihara dan dikelola dengan baik dapat ditulis di sini. Ditunggu PR-nya!
12 - Prioritas dan Kesetaraan API (API Priority and Fairness)
=============================================================
FEATURE STATE: `Kubernetes v1.18 [alpha]`
Mengontrol perilaku server API dari Kubernetes pada situasi beban berlebih merupakan tugas utama dari administrator klaster. [kube-apiserver](https://kubernetes.io/id/docs/reference/generated/kube-apiserver/ "Komponen control plane yang mengekspos API Kubernetes. Merupakan front-end dari control plane Kubernetes.")
memiliki beberapa kontrol yang tersedia (seperti opsi `--max-request-inflight` dan `--max-mutating-request-inflight` pada baris perintah atau _command-line_) untuk membatasi jumlah pekerjaan luar biasa yang akan diterima, untuk mencegah banjirnya permintaan masuk dari beban berlebih yang berpotensi untuk menghancurkan server API. Namun opsi ini tidak cukup untuk memastikan bahwa permintaan yang paling penting dapat diteruskan pada saat kondisi lalu lintas (_traffic_) yang cukup tinggi.
Fitur Prioritas dan Kesetaraan API atau _API Priority and Fairness_ (APF) adalah alternatif untuk meningkatkan batasan _max-inflight_ seperti yang disebutkan di atas. APF mengklasifikasi dan mengisolasi permintaan dengan cara yang lebih halus. Fitur ini juga memperkenalkan jumlah antrian yang terbatas, sehingga tidak ada permintaan yang ditolak pada saat terjadi lonjakan permintaan dalam waktu yang sangat singkat. Permintaan dibebaskan dari antrian dengan menggunakan teknik antrian yang adil (_fair queuing_) sehingga, sebagai contoh, perilaku buruk dari satu [controller](https://kubernetes.io/id/docs/concepts/architecture/controller/ "Kontrol tertutup yang mengawasi kondisi bersama dari klaster melalui apiserver dan membuat perubahan yang mencoba untuk membawa kondisi saat ini ke kondisi yang diinginkan.")
tidak seharusnya mengakibatkan _controller_ yang lain menderita (meskipun pada tingkat prioritas yang sama).
#### Perhatian:
Permintaan yang diklasifikasikan sebagai "long running" - terutama _watch_ - tidak mengikuti filter prioritas dan kesetaraan API. Dimana ini juga berlaku pada opsi `--max-request-inflight` tanpa mengaktifkan APF.
Mengaktifkan prioritas dan kesetaraan API
-----------------------------------------
Fitur APF dikontrol oleh sebuah gerbang fitur (_feature gate_) dan fitur ini tidak diaktifkan secara bawaan. Silahkan lihat [gerbang fitur](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/)
untuk penjelasan umum tentang gerbang fitur dan bagaimana cara mengaktifkan dan menonaktifkannya. Nama gerbang fitur untuk APF adalah "APIPriorityAndFairness". Fitur ini melibatkan sebuah [Grup API](https://kubernetes.io/id/docs/concepts/overview/kubernetes-api/#api-groups "Sekumpulan path terkait pada API Kubernetes.")
yang harus juga diaktifkan. Kamu bisa melakukan ini dengan menambahkan opsi pada baris perintah berikut pada permintaan ke `kube-apiserver` kamu:
kube-apiserver \
--feature-gates=APIPriorityAndFairness=true \
--runtime-config=flowcontrol.apiserver.k8s.io/v1alpha1=true \
# …dan opsi-opsi lainnya seperti biasa
Opsi pada baris perintah `--enable-priority-and-fairness=false` akan menonaktifkan fitur APF, bahkan ketika opsi yang lain telah mengaktifkannya.
Konsep
------
Ada beberapa fitur lainnya yang terlibat dalam fitur APF. Permintaan yang masuk diklasifikasikan berdasarkan atribut permintaan dengan menggunakan FlowSchema, dan diserahkan ke tingkat prioritas. Tingkat prioritas menambahkan tingkat isolasi dengan mempertahankan batas konkurensi yang terpisah, sehingga permintaan yang diserahkan ke tingkat prioritas yang berbeda tidak dapat membuat satu sama lain menderita. Dalam sebuah tingkat prioritas, algoritma _fair-queuing_ mencegah permintaan dari _flows_ yang berbeda akan memberikan penderitaan kepada yang lainnya, dan memperbolehkan permintaan untuk dimasukkan ke dalam antrian untuk mencegah pelonjakan lalu lintas yang akan menyebabkan gagalnya permintaan, walaupun pada saat beban rata-ratanya cukup rendah.
### Tingkat prioritas (_Priority Level_)
Tanpa pengaktifan APF, keseluruhan konkurensi dalam server API dibatasi oleh opsi pada `kube-apiserver` `--max-request-inflight` dan `--max-mutating-request-inflight`. Dengan pengaktifan APF, batas konkurensi yang ditentukan oleh opsi ini akan dijumlahkan dan kemudian jumlah tersebut dibagikan untuk sekumpulan tingkat prioritas (_priority level_) yang dapat dikonfigurasi. Setiap permintaan masuk diserahkan ke sebuah tingkat prioritas, dan setiap tingkat prioritas hanya akan meneruskan sebanyak mungkin permintaan secara bersamaan sesuai dengan yang diijinkan dalam konfigurasi.
Konfigurasi bawaan, misalnya, sudah mencakup tingkat prioritas terpisah untuk permintaan dalam rangka pemilihan pemimpin (_leader-election_), permintaan dari _controller_ bawaan, dan permintaan dari Pod. Hal ini berarti bahwa Pod yang berperilaku buruk, yang bisa membanjiri server API dengan permintaan, tidak akan mampu mencegah kesuksesan pemilihan pemimpin atau tindakan yang dilakukan oleh _controller_ bawaan.
### Antrian (_Queuing_)
Bahkan dalam sebuah tingkat prioritas mungkin akan ada sumber lalu lintas yang berbeda dalam jumlah besar. Dalam situasi beban berlebih, sangat penting untuk mencegah satu aliran permintaan dari penderitaan karena aliran yang lainnya (khususnya, dalam kasus yang relatif umum dari sebuah klien tunggal bermasalah (_buggy_) yang dapat membanjiri _kube-apiserver_ dengan permintaan, klien bermasalah itu idealnya tidak memiliki banyak dampak yang bisa diukur terhadap klien yang lainnya). Hal ini ditangani dengan menggunakan algoritma _fair-queuing_ untuk memproses permintaan yang diserahkan oleh tingkat prioritas yang sama. Setiap permintaan diserahkan ke sebuah _flow_, yang diidentifikasi berdasarkan nama FlowSchema yang sesuai, ditambah dengan _flow distinguisher_ - yang bisa saja didasarkan pada pengguna yang meminta, sumber daya Namespace dari target, atau tidak sama sekali - dan sistem mencoba untuk memberikan bobot yang hampir sama untuk permintaan dalam _flow_ yang berbeda dengan tingkat prioritas yang sama.
Setelah mengklasifikasikan permintaan ke dalam sebuah _flow_, fitur APF kemudian dapat menyerahkan permintaan ke dalam sebuah antrian. Penyerahan ini menggunakan teknik yang dikenal sebagai [\_shuffle sharding\_](https://kubernetes.io/id/docs/reference/glossary/?all=true#term-shuffle-sharding "A technique for assigning requests to queues that provides better isolation than hashing modulo the number of queues.")
, yang membuat penggunaan antrian yang relatif efisien untuk mengisolasi _flow_ dengan intensitas rendah dari _flow_ dengan intensitas tinggi.
Detail dari algoritma antrian dapat disesuaikan untuk setiap tingkat prioritas, dan memperbolehkan administrator untuk menukar (_trade off_) dengan penggunaan memori, kesetaraan (properti dimana _flow_ yang independen akan membuat semua kemajuan ketika total dari lalu lintas sudah melebihi kapasitas), toleransi untuk lonjakan lalu lintas, dan penambahan latensi yang dihasilkan oleh antrian.
### Permintaan yang dikecualikan (_Exempt Request_)
Beberapa permintaan dianggap cukup penting sehingga mereka tidak akan mengikuti salah satu batasan yang diberlakukan oleh fitur ini. Pengecualian ini untuk mencegah konfigurasi _flow control_ yang tidak terkonfigurasi dengan baik sehingga tidak benar-benar menonaktifkan server API.
Bawaan (_Default_)
------------------
Fitur APF dikirimkan dengan konfigurasi yang disarankan dimana konfigurasi itu seharusnya cukup untuk bereksperimen; jika klaster kamu cenderung mengalami beban berat maka kamu harus mempertimbangkan konfigurasi apa yang akan bekerja paling baik. Kelompok konfigurasi yang disarankan untuk semua permintaan terbagi dalam lima prioritas kelas:
* Tingkat prioritas `system` diperuntukkan bagi permintaan dari grup `system:nodes`, mis. Kubelet, yang harus bisa menghubungi server API agar mendapatkan _workload_ untuk dijadwalkan.
* Tingkat prioritas `leader-election` diperuntukkan bagi permintaan dalam pemilihan pemimpin (_leader election_) dari _controller_ bawaan (khususnya, permintaan untuk `endpoint`, `configmaps`, atau `leases` yang berasal dari `system:kube-controller-manager` atau pengguna `system:kube-scheduler` dan akun Service di Namespace `kube-system`). Hal ini penting untuk mengisolasi permintaan ini dari lalu lintas yang lain karena kegagalan dalam pemilihan pemimpin menyebabkan _controller_ akan gagal dan memulai kembali (_restart_), yang pada akhirnya menyebabkan lalu lintas yang lebih mahal karena _controller_ yang baru perlu menyinkronkan para informannya.
* Tingkat prioritas `workload-high` diperuntukkan bagi permintaan yang lain dari _controller_ bawaan.
* Tingkat prioritas `workload-low` diperuntukkan bagi permintaan dari akun Service yang lain, yang biasanya mencakup semua permintaan dari _controller_ yang bekerja didalam Pod.
* Tingkat prioritas `global-default` menangani semua lalu lintas lainnya, mis. perintah interaktif `kubectl` yang dijalankan oleh pengguna yang tidak memiliki hak khusus.
Kemudian, ada dua PriorityLevelConfiguration dan dua FlowSchema yang telah dibangun dan tidak mungkin ditimpa ulang:
* Tingkat prioritas khusus `exempt` diperuntukkan bagi permintaan yang tidak akan dikenakan _flow control_ sama sekali: permintaan itu akan selalu diteruskan sesegera mungkin. FlowSchema `exempt` khusus mengklasifikasikan semua permintaan dari kelompok `system:masters` ke dalam tingkat prioritas khusus ini. Kamu juga dapat menentukan FlowSchema lain yang mengarahkan permintaan lain ke tingkat prioritas ini juga, apabila permintaan tersebut sesuai.
* Tingkat prioritas khusus `catch-all` digunakan secara kombinasi dengan spesial FlowSchema `catch-all` untuk memastikan bahwa setiap permintaan mendapatkan proses klasifikasi. Biasanya kamu tidak harus bergantung pada konfigurasi _catch-all_ ini, dan kamu seharusnya membuat FlowSchema _catch-all_ dan PriorityLevelConfiguration kamu sendiri (atau gunakan konfigurasi `global-default` yang sudah diinstal secara bawaan) secara benar. Untuk membantu menemukan kesalahan konfigurasi yang akan melewatkan beberapa klasifikasi permintaan, maka tingkat prioritas `catch-all` hanya wajib mengijinkan satu konkurensi bersama dan tidak melakukan memasukkan permintaan dalam antrian, sehingga membuat lalu lintas yang secara relatif hanya sesuai dengan FlowSchema `catch-all` akan ditolak dengan kode kesalahan HTTP 429.
Sumber daya (_Resource_)
------------------------
_Flow control_ API melibatkan dua jenis sumber daya. [PriorityLevelConfiguration](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/#prioritylevelconfiguration-v1alpha1-flowcontrol-apiserver-k8s-io)
yang menentukan kelas isolasi yang tersedia, bagian dari konkurensi anggaran yang tersedia yang masing-masing dapat menangani bagian tersebut, dan memperbolehkan untuk melakukan _fine-tuning_ terhadap perilaku antrian. [FlowSchema](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/#flowschema-v1alpha1-flowcontrol-apiserver-k8s-io)
yang digunakan untuk mengklasifikasikan permintaan individu yang masuk, mencocokkan masing-masing dengan setiap PriorityLevelConfiguration.
### PriorityLevelConfiguration
Sebuah PriorityLevelConfiguration merepresentasikan sebuah kelas isolasi tunggal. Setiap PriorityLevelConfiguration memiliki batas independensi dalam hal jumlah permintaan yang belum diselesaikan, dan batasan dalam hal jumlah permintaan yang mengantri.
Batas konkurensi untuk PriorityLevelConfiguration tidak disebutkan dalam jumlah permintaan secara mutlak, melainkan dalam "concurrency shares." Total batas konkurensi untuk server API didistribusikan di antara PriorityLevelConfiguration yang ada secara proporsional dengan "concurrency shares" tersebut. Ini mengizinkan seorang administrator klaster untuk meningkatkan atau menurunkan jumlah total lalu lintas ke sebuah server dengan memulai kembali `kube-apiserver` dengan nilai opsi `--max-request-inflight` (atau `--max-mutating-request-inflight`) yang berbeda, dan semua PriorityLevelConfiguration akan melihat konkurensi maksimum yang diizinkan kepadanya untuk menaikkan (atau menurunkan) dalam fraksi yang sama.
#### Perhatian:
Dengan fitur Prioritas dan Kesetaraan yang diaktifkan, batas total konkurensi untuk server diatur pada nilai penjumlahan dari `--max-request-inflight` dan `--max-mutating-request-inflight`. Tidak akan ada lagi perbedaan antara permintaan yang bermutasi dan permintaan yang tidak bermutasi; jika kamu ingin melayaninya secara terpisah untuk suatu sumber daya yang ada, maka perlu membuat FlowSchema terpisah yang sesuai dengan masing-masing kata kerja dari permintaan yang bermutasi dan yang tidak bermutasi tersebut.
Ketika jumlah permintaan masuk yang diserahkan kepada sebuah PriorityLevelConfiguration melebihi dari tingkat konkurensi yang diizinkan, bagian `type` dari spesifikasinya menentukan apa yang akan terjadi pada permintaan selanjutnya. Tipe `Reject` berarti bahwa kelebihan lalu lintas akan segera ditolak dengan kode kesalahan HTTP 429 (yang artinya terlalu banyak permintaan). Tipe `Queue` berarti permintaan di atas batas tersebut akan mengantri, dengan teknik _sharding shuffle_ dan _fair queuing_ yang digunakan untuk menyelaraskan kemajuan antara _flow_ permintaan.
Konfigurasi antrian memungkinkan mengatur algoritma _fair queuing_ untuk sebuah tingkat prioritas. Detail algoritma dapat dibaca di [proposal pembaharuan](https://github.com/kubernetes/enhancements/tree/master/keps/sig-api-machinery/1040-priority-and-fairness)
, namun secara singkat:
* Meningkatkan `queue` (antrian) berarti mengurangi tingkat tabrakan antara _flow_ yang berbeda, sehingga berakibat pada biaya untuk meningkatkan penggunaan memori. Nilai 1 di sini secara efektif menonaktifkan logika _fair-queuing_, tetapi masih mengizinkan permintaan untuk dimasukkan kedalam antrian.
* Meningkatkan `queueLengthLimit` berarti memperbolehkan lonjakan yang lebih besar dari lalu lintas untuk berkelanjutan tanpa menggagalkan permintaan apa pun, dengan konsekuensi akan meningkatkan latensi dan penggunaan memori.
* Mengubah `handSize` berarti memperbolehkan kamu untuk menyesuaikan probabilitas tabrakan antara _flow_ yang berbeda dan keseluruhan konkurensi yang tersedia untuk satu _flow_ tunggal dalam situasi beban berlebih.
#### Catatan:
`HandSize` yang lebih besar membuat dua _flow_ individual berpeluang kecil untuk bertabrakan
(dan dimana _flow_ yang satu bisa membuat _flow_ yang lain menderita), tetapi akan lebih memungkinkan
bahwa _flow_ dalam jumlah kecil akan dapat mendominasi apiserver. `HandSize` yang lebih besar juga
berpotensi meningkatkan jumlah latensi yang diakibatkan oleh satu _flow_ lalu lintas tunggal
yang tinggi. Jumlah maksimum permintaan dalam antrian yang diijinkan dari sebuah _flow_ tunggal
adalah `handSize * queueLengthLimit`.
Berikut ini adalah tabel yang menunjukkan koleksi konfigurasi _shuffle sharding_ yang menarik, dimana setiap probabilitas _mouse_ (_flow_ dengan intensitas rendah) yang diberikan akan dimampatkan oleh _elephant_ (_flow_ dengan intensitas tinggi) dalam sebuah koleksi ilustratif dari jumlah _elephant_ yang berbeda. Silahkan lihat pada [https://play.golang.org/p/Gi0PLgVHiUg](https://play.golang.org/p/Gi0PLgVHiUg)
, yang digunakan untuk menghitung nilai-nilai dalam tabel ini.
| | | | | |
| --- | --- | --- | --- | --- |Contoh Konfigurasi Shuffle Sharding
| HandSize | Queues | 1 elephant | 4 elephants | 16 elephants |
| --- | --- | --- | --- | --- |
| 12 | 32 | 4.428838398950118e-09 | 0.11431348830099144 | 0.9935089607656024 |
| 10 | 32 | 1.550093439632541e-08 | 0.0626479840223545 | 0.9753101519027554 |
| 10 | 64 | 6.601827268370426e-12 | 0.00045571320990370776 | 0.49999929150089345 |
| 9 | 64 | 3.6310049976037345e-11 | 0.00045501212304112273 | 0.4282314876454858 |
| 8 | 64 | 2.25929199850899e-10 | 0.0004886697053040446 | 0.35935114681123076 |
| 8 | 128 | 6.994461389026097e-13 | 3.4055790161620863e-06 | 0.02746173137155063 |
| 7 | 128 | 1.0579122850901972e-11 | 6.960839379258192e-06 | 0.02406157386340147 |
| 7 | 256 | 7.597695465552631e-14 | 6.728547142019406e-08 | 0.0006709661542533682 |
| 6 | 256 | 2.7134626662687968e-12 | 2.9516464018476436e-07 | 0.0008895654642000348 |
| 6 | 512 | 4.116062922897309e-14 | 4.982983350480894e-09 | 2.26025764343413e-05 |
| 6 | 1024 | 6.337324016514285e-16 | 8.09060164312957e-11 | 4.517408062903668e-07 |
### FlowSchema
FlowSchema mencocokkan beberapa permintaan yang masuk dan menetapkan permintaan ke dalam sebuah tingkat prioritas. Setiap permintaan masuk diuji dengan setiap FlowSchema secara bergiliran, dimulai dari yang terendah secara numerik --- yang kita anggap sebagai yang tertinggi secara logis --- `matchingPrecedence` dan begitu seterusnya. FlowSchema yang cocok pertama kali akan menang.
#### Perhatian:
Hanya FlowSchema yang pertama kali cocok untuk permintaan yang diberikan yang akan dianggap penting. Jika ada banyak FlowSchema yang cocok dengan sebuah permintaan masuk, maka akan ditetapkan berdasarkan salah satu yang mempunyai `matchingPrecedence` tertinggi. Jika ada beberapa FlowSchema dengan nilai `matchingPrecedence` yang sama dan cocok dengan permintaan yang sama juga, permintaan dengan leksikografis `name` yang lebih kecil akan menang, tetapi akan lebih baik untuk tidak mengandalkan metode ini, dan sebaiknya perlu memastikan bahwa tidak ada dua FlowSchema yang memiliki `matchingPrecedence` yang sama.
Sebuah FlowSchema dianggap cocok dengan sebuah permintaan yang diberikan jika setidaknya salah satu dari `rules` nya ada yang cocok. Sebuah aturan (_rule_) cocok jika setidaknya satu dari `subject` _dan_ ada salah satu dari `resourceRules` atau `nonResourceRules` (tergantung dari apakah permintaan yang masuk adalah untuk URL sumber daya atau non-sumber daya) yang cocok dengan permintaan tersebut.
Untuk bagian `name` dalam subjek, dan bagian `verbs`, `apiGroups`, `resources`, `namespaces`, dan `nonResourceURLs` dalam aturan sumber daya dan non-sumber daya, _wildcard_ `*` mungkin bisa ditetapkan untuk mencocokkan semua nilai pada bagian yang diberikan, sehingga secara efektif menghapusnya dari pertimbangan.
Sebuah `DistinguisherMethod.type` dari FlowSchema menentukan bagaimana permintaan yang cocok dengan Skema itu akan dipisahkan menjadi _flow_. Nilai tipe itu bisa jadi `ByUser`, dalam hal ini satu pengguna yang meminta tidak akan bisa menghabiskan kapasitas dari pengguna lain, atau bisa juga `ByNamespace`, dalam hal ini permintaan sumber daya di salah satu Namespace tidak akan bisa menyebabkan penderitaan bagi permintaan akan sumber daya dalam kapasitas Namespace yang lain, atau bisa juga kosong (atau `distinguisherMethod` dihilangkan seluruhnya), dalam hal ini semua permintaan yang cocok dengan FlowSchema ini akan dianggap sebagai bagian dari sebuah _flow_ tunggal. Pilihan yang tepat untuk FlowSchema yang diberikan akan bergantung pada sumber daya dan lingkungan khusus kamu.
Diagnosis
---------
Setiap respons HTTP dari server API dengan fitur prioritas dan kesetaraan yang diaktifkan memiliki dua _header_ tambahan: `X-Kubernetes-PF-FlowSchema-UID` dan `X-Kubernetes-PF-PriorityLevel-UID`, yang mencatat skema _flow_ yang cocok dengan permintaan dan tingkat prioritas masing-masing. Name Objek API tidak termasuk dalam _header_ ini jika pengguna peminta tidak memiliki izin untuk melihatnya, jadi ketika melakukan _debugging_ kamu dapat menggunakan perintah seperti ini
kubectl get flowschema -o custom-columns="uid:{metadata.uid},name:{metadata.name}"
kubectl get prioritylevelconfiguration -o custom-columns="uid:{metadata.uid},name:{metadata.name}"
untuk mendapatkan pemetaan UID ke names baik untuk FlowSchema maupun PriorityLevelConfiguration.
Observabilitas
--------------
Saat kamu mengaktifkan fitur Prioritas dan Kesetaraan API atau APF, kube-apiserver akan mengeluarkan metrik tambahan. Dengan memantau metrik ini dapat membantu kamu untuk menentukan apakah konfigurasi kamu tidak tepat dalam membatasi lalu lintas yang penting, atau menemukan beban kerja yang berperilaku buruk yang dapat membahayakan kesehatan dari sistem.
* `apiserver_flowcontrol_rejected_requests_total` menghitung permintaan yang ditolak, mengelompokkannya berdasarkan nama dari tingkat prioritas yang ditetapkan, nama FlowSchema yang ditetapkan, dan alasan penolakan tersebut. Alasan penolakan akan mengambil dari salah satu alasan-alasan berikut:
* `queue-full`, yang mengindikasikan bahwa sudah terlalu banyak permintaan yang menunggu dalam antrian,
* `concurrency-limit`, yang mengindikasikan bahwa PriorityLevelConfiguration telah dikonfigurasi untuk menolak, bukan untuk memasukan permintaan berlebih ke dalam antrian, atau
* `time-out`, yang mengindikasikan bahwa permintaan masih dalam antrian ketika batas waktu antriannya telah berakhir.
* `apiserver_flowcontrol_dispatched_requests_total` menghitung permintaan yang sudah mulai dieksekusi, mengelompokkannya berdasarkan nama dari tingkat prioritas yang ditetapkan, dan nama dari FlowSchema yang ditetapkan.
* `apiserver_flowcontrol_current_inqueue_requests` memberikan jumlah total sesaat secara instan dari permintaan dalam antrian (bukan yang dieksekusi), dan mengelompokkannya berdasarkan tingkat prioritas dan FlowSchema.
* `apiserver_flowcontrol_current_executing_requests` memberikan jumlah total yang instan dari permintaan yang dieksekusi, dan mengelompokkannya berdasarkan tingkat prioritas dan FlowSchema.
* `apiserver_flowcontrol_request_queue_length_after_enqueue` memberikan histogram dari panjang antrian untuk semua antrian yang ada, mengelompokkannya berdasarkan tingkat prioritas dan FlowSchema, berdasarkan pengambilan sampel oleh permintaan _enqueued_. Setiap permintaan yang mendapatkan antrian berkontribusi ke satu sampel dalam histogramnya, pelaporan panjang antrian dilakukan setelah permintaan yang mengantri tersebut ditambahkan. Perlu dicatat bahwa ini akan menghasilkan statistik yang berbeda dengan survei yang tidak bias.
#### Catatan:
Nilai asing atau tidak biasa dalam histogram akan berarti ada kemungkinan sebuah _flow_
(misalnya, permintaan oleh satu pengguna atau untuk satu _namespace_, tergantung pada
konfigurasinya) telah membanjiri server API, dan sedang dicekik. Sebaliknya, jika
histogram dari satu tingkat prioritas menunjukkan bahwa semua antrian dalam prioritas
level itu lebih panjang daripada level prioritas yang lainnya, mungkin akan sesuai
untuk meningkatkan _concurrency shares_ dari PriorityLevelConfiguration itu.
* `apiserver_flowcontrol_request_concurrency_limit` memberikan hasil perhitungan batas konkurensi (berdasarkan pada batas konkurensi total dari server API dan _concurrency share_ dari PriorityLevelConfiguration) untuk setiap PriorityLevelConfiguration.
* `apiserver_flowcontrol_request_wait_duration_seconds` memberikan histogram tentang bagaimana permintaan yang panjang dihabiskan dalam antrian, mengelompokkannya berdasarkan FlowSchema yang cocok dengan permintaan, tingkat prioritas yang ditetapkan, dan apakah permintaan tersebut berhasil dieksekusi atau tidak.
#### Catatan:
Karena setiap FlowSchema selalu memberikan permintaan untuk satu
PriorityLevelConfiguration, kamu dapat menambahkan histogram untuk semua
FlowSchema dalam satu tingkat prioritas untuk mendapatkan histogram yang efektif
dari permintaan yang ditetapkan ke tingkat prioritas tersebut.
* `apiserver_flowcontrol_request_execution_seconds` memberikan histogram tentang bagaimana caranya permintaan yang panjang diambil untuk benar-benar dieksekusi, mengelompokkannya berdasarkan FlowSchema yang cocok dengan permintaan dan tingkat prioritas yang ditetapkan pada permintaan tersebut.
Selanjutnya
-----------
Untuk latar belakang informasi mengenai detail desain dari prioritas dan kesetaraan API, silahkan lihat [proposal pembaharuan](https://github.com/kubernetes/enhancements/tree/master/keps/sig-api-machinery/1040-priority-and-fairness)
. Kamu juga dapat membuat saran dan permintaan akan fitur melalui [SIG API Machinery](https://github.com/kubernetes/community/tree/master/sig-api-machinery)
.
---
# Konfiguracja | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/concepts/configuration/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/concepts/configuration/)
.
Konfiguracja
============
Zasoby Kubernetesa wykorzystywane do konfiguracji Podów.
---
# Amministrazione del Cluster | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/concepts/cluster-administration/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/concepts/cluster-administration/)
.
Amministrazione del Cluster
===========================
* 1: [Proxy in Kubernetes](https://kubernetes.io/it/docs/concepts/cluster-administration/_print/#pg-08e94e6a480e0d6b2de72d84a1b97617)
1 - Proxy in Kubernetes
=======================
Questa pagina spiega i proxy utilizzati con Kubernetes.
Proxy
-----
Esistono diversi proxy che puoi incontrare quando usi Kubernetes:
1. Il [kubectl proxy](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#direct-accessing-the-rest-api)
:
- viene eseguito sul computer di un utente o in un pod - collega un localhost address all'apiserver di Kubernetes - il client comunica con il proxy in HTTP - il proxy comunica con l'apiserver in HTTPS - individua l'apiserver - aggiunge gli header di autenticazione
1. L'[apiserver proxy](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster-services/#discovering-builtin-services)
:
- è un proxy presente nell'apiserver - collega un utente al di fuori del cluster agli IP del cluster che altrimenti potrebbero non essere raggiungibili - è uno dei processi dell'apiserver - il client comunica con il proxy in HTTPS (o HTTP se l'apiserver è configurato in tal modo) - il proxy comunica con il target via HTTP o HTTPS come scelto dal proxy utilizzando le informazioni disponibili - può essere utilizzato per raggiungere un nodo, un pod o un servizio - esegue il bilanciamento del carico quando viene utilizzato per raggiungere un servizio
1. Il [kube proxy](https://kubernetes.io/docs/concepts/services-networking/service/#ips-and-vips)
:
- è eseguito su ciascun nodo - fa da proxy per comunicazioni UDP, TCP e SCTP - non gestisce il protocollo HTTP - esegue il bilanciamento del carico - è usato solo per raggiungere i servizi
1. Un proxy/bilanciatore di carico di fronte agli apiserver:
- la sua esistenza e implementazione variano da cluster a cluster (ad esempio nginx) - si trova tra i client e uno o più apiserver - funge da bilanciatore di carico se ci sono più di un apiserver.
1. Cloud Load Balancer su servizi esterni:
- sono forniti da alcuni fornitori di servizi cloud (ad es. AWS ELB, Google Cloud Load Balancer) - vengono creati automaticamente quando il servizio Kubernetes ha tipo `LoadBalancer` - solitamente supporta solo UDP / TCP - il supporto SCTP dipende dall'implementazione del bilanciatore di carico del provider cloud - l'implementazione varia a seconda del provider cloud.
Gli utenti di Kubernetes in genere non devono preoccuparsi alcun proxy, se non i primi due tipi. L'amministratore del cluster in genere assicurerà che gli altri tipi di proxy siano impostati correttamente.
Richiedere reindirizzamenti
---------------------------
I proxy hanno sostituito le funzioni di reindirizzamento. I reindirizzamenti sono stati deprecati.
---
# Kubernetes — Dokumentacja | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/home/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/home/)
.
Kubernetes — Dokumentacja
=========================
Kubernetes to otwarte oprogramowanie służące do automatyzacji procesów uruchamiania, skalowania i zarządzania aplikacjami w kontenerach. Gospodarzem tego projektu o otwartym kodzie źródłowym jest Cloud Native Computing Foundation.
* 1: [Dostępne wersje dokumentacji](https://kubernetes.io/pl/docs/home/_print/#pg-92dfff0ca612d0bff40171aa9df6c4ae)
1 - Dostępne wersje dokumentacji
================================
Ten serwis zawiera dokumentację do bieżącej i czterech poprzednich wersji Kubernetesa.
Dostępność dokumentacji obejmującej konkretną wersję Kubernetesa nie oznacza automatycznie, że dana wersja Kubernetesa jest ciągle aktywnie wspierana. Zajrzyj do dokumentu [Support period](https://kubernetes.io/releases/patch-releases/#support-period)
, aby dowiedzieć się, do kiedy objęte wsparciem są poszczególne wersje Kubernetesa.
---
# TLS | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/tasks/tls/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/tasks/tls/)
.
TLS
===
अपने क्लस्टर के भीतर ट्रैफ़िक को ट्रांसपोर्ट लेयर सिक्योरिटी (टीएलएस) का उपयोग करके सुरक्षित करना समझें।
* 1: [क्यूबलेट के लिए प्रमाणपत्र आवर्तन कॉन्फ़िगर करें](https://kubernetes.io/hi/docs/tasks/tls/_print/#pg-1272b18ac0c008f6ffc2c62a29fa929f)
1 - क्यूबलेट के लिए प्रमाणपत्र आवर्तन कॉन्फ़िगर करें
====================================================
यह पृष्ठ दिखाता है कि क्यूबलेट के लिए प्रमाणपत्र आवर्तन कैसे सक्षम और कॉन्फ़िगर कर सकते है।
फ़ीचर स्थिति: `Kubernetes v1.19 [stable]`
शुरू करने से पहले
-----------------
* कम से कम कुबेरनेट्स संस्करण 1.8.0 या उसके बाद की आवश्यकता है।
अवलोकन
------
क्यूबलेट प्रमाणपत्रों का उपयोग कुबरनेट्स API के साथ प्रमाणित करने के लिए करता है। डिफ़ॉल्ट रूप से, ये प्रमाणपत्र एक वर्ष की समाप्ति के साथ जारी किए जाते हैं ताकि उन्हें बार-बार नवीनीकृत करने की आवश्यकता न हो।
कुबरनेट्स में [क्यूबलेट प्रमाणपत्र आवर्तन](https://kubernetes.io/docs/reference/access-authn-authz/kubelet-tls-bootstrapping/)
शामिल है, जो स्वचालित रूप से एक नई कुंजी उत्पन्न करेगा जो स्वचालित रूप से एक नई कुंजी उत्पन्न करेगा और वर्तमान प्रमाणपत्र की समाप्ति के करीब आने पर कुबरनेट्स API से एक नया प्रमाणपत्र अनुरोध करेगा। एक बार नया प्रमाणपत्र उपलब्ध हो जाने पर, यह कुबरनेट्स API के साथ कनेक्शन को प्रमाणित करने के लिए उपयोग किया जाएगा।
क्लाइंट प्रमाणपत्र रोटेशन सक्षम करना
------------------------------------
`kubelet` प्रक्रिया एक प्राचल `--rotate-certificates` स्वीकार करती है जो नियंत्रित करती है कि क्या कुबलेट स्वचालित रूप से वर्तमान में उपयोग किए जा रहे प्रमाणपत्र की समाप्ति के करीब आने पर एक नया प्रमाणपत्र अनुरोध करेगा।
`kube-controller-manager` प्रक्रिया एक प्राचल स्वीकार करती है `--cluster-signing-duration` (`--experimental-cluster-signing-duration` 1.19 से पहले) जो नियंत्रित करता है कि प्रमाणपत्र कितने समय के लिए जारी किए जाएंगे।
प्रमाणपत्र रोटेशन कॉन्फ़िगरेशन को समझना
---------------------------------------
जब एक कुबलेट शुरू होता है, यदि इसे बूटस्ट्रैप करने के लिए कॉन्फ़िगर किया गया है (उपयोग करते हुए `--bootstrap-kubeconfig` फ्लैग), तो यह कुबरनेट्स API से कनेक्ट करने और एक प्रमाणपत्र हस्ताक्षर अनुरोध जारी करने के लिए अपने प्रारंभिक प्रमाणपत्र का उपयोग करेगा। आप प्रमाणपत्र हस्ताक्षर अनुरोधों की स्थिति देख सकते हैं:
kubectl get csr
शुरुआत में, किसी नोड पर कुबलेट से एक प्रमाणपत्र हस्ताक्षर अनुरोध की स्थिति `Pending` होगी। यदि प्रमाणपत्र हस्ताक्षर अनुरोध विशिष्ट मानदंडों को पूरा करता है, तो इसे नियंत्रक प्रबंधक द्वारा स्वचालित रूप से अनुमोदित किया जाएगा, और फिर इसकी स्थिति `Approved` होगी। इसके बाद, नियंत्रक प्रबंधक एक प्रमाणपत्र पर हस्ताक्षर करेगा, जो `--cluster-signing-duration` पैरामीटर द्वारा निर्दिष्ट अवधि के लिए जारी किया जाएगा, और हस्ताक्षरित प्रमाणपत्र को प्रमाणपत्र हस्ताक्षर अनुरोध से जोड़ा जाएगा।
कुबलेट कुबरनेट्स API से हस्ताक्षरित प्रमाणपत्र प्राप्त करेगा और इसे डिस्क पर लिखेगा, `--cert-dir` द्वारा निर्दिष्ट स्थान में। फिर कुबलेट कुबरनेट्स API से कनेक्ट करने के लिए नए प्रमाणपत्र का उपयोग करेगा।
जैसे ही हस्ताक्षरित प्रमाणपत्र की समाप्ति निकट आती है, कुबलेट स्वचालित रूप से कुबरनेट्स API का उपयोग करके एक नया प्रमाणपत्र हस्ताक्षर अनुरोध जारी करेगा। यह प्रमाणपत्र पर शेष समय के 30% और 10% के बीच किसी भी बिंदु पर हो सकता है। फिर से, नियंत्रक प्रबंधक स्वचालित रूप से प्रमाणपत्र अनुरोध को अनुमोदित करेगा और प्रमाणपत्र हस्ताक्षर अनुरोध से एक हस्ताक्षरित प्रमाणपत्र जोड़ेगा। कुबलेट कुबरनेट्स API से नया हस्ताक्षरित प्रमाणपत्र प्राप्त करेगा और इसे डिस्क पर लिखेगा। फिर यह कुबरनेट्स API के साथ कनेक्शन को नए प्रमाणपत्र का उपयोग करके पुन: कनेक्ट करने के लिए अपडेट करेगा।
---
# Kubectl Reference Docs
* [**GETTING STARTED**](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-strong-getting-started-strong-)
* [create](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#create)
* [_clusterrole_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-clusterrole-em-)
* [_clusterrolebinding_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-clusterrolebinding-em-)
* [_configmap_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-configmap-em-)
* [_cronjob_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-cronjob-em-)
* [_deployment_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-deployment-em-)
* [_ingress_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-ingress-em-)
* [_job_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-job-em-)
* [_namespace_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-namespace-em-)
* [_poddisruptionbudget_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-poddisruptionbudget-em-)
* [_priorityclass_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-priorityclass-em-)
* [_quota_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-quota-em-)
* [_role_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-role-em-)
* [_rolebinding_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-rolebinding-em-)
* [_secret_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-secret-em-)
* [_secret docker-registry_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-secret-docker-registry-em-)
* [_secret generic_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-secret-generic-em-)
* [_secret tls_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-secret-tls-em-)
* [_service_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-service-em-)
* [_service clusterip_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-service-clusterip-em-)
* [_service externalname_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-service-externalname-em-)
* [_service loadbalancer_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-service-loadbalancer-em-)
* [_service nodeport_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-service-nodeport-em-)
* [_serviceaccount_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-serviceaccount-em-)
* [_token_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-token-em-)
* [get](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#get)
* [run](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#run)
* [expose](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#expose)
* [delete](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#delete)
* [**APP MANAGEMENT**](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-strong-app-management-strong-)
* [apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply)
* [_edit-last-applied_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-edit-last-applied-em-)
* [_set-last-applied_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-set-last-applied-em-)
* [_view-last-applied_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-view-last-applied-em-)
* [annotate](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#annotate)
* [autoscale](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#autoscale)
* [debug](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#debug)
* [diff](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#diff)
* [edit](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#edit)
* [kustomize](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#kustomize)
* [label](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#label)
* [patch](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#patch)
* [replace](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#replace)
* [rollout](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#rollout)
* [_history_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-history-em-)
* [_pause_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-pause-em-)
* [_restart_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-restart-em-)
* [_resume_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-resume-em-)
* [_status_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-status-em-)
* [_undo_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-undo-em-)
* [scale](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#scale)
* [set](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#set)
* [_env_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-env-em-)
* [_image_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-image-em-)
* [_resources_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-resources-em-)
* [_selector_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-selector-em-)
* [_serviceaccount_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-serviceaccount-em--1)
* [_subject_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-subject-em-)
* [wait](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#wait)
* [**WORKING WITH APPS**](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-strong-working-with-apps-strong-)
* [attach](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#attach)
* [auth](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#auth)
* [_can-i_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-can-i-em-)
* [_reconcile_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-reconcile-em-)
* [cp](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#cp)
* [describe](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#describe)
* [events](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#events)
* [exec](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#exec)
* [logs](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#logs)
* [port-forward](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#port-forward)
* [proxy](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#proxy)
* [top](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#top)
* [_node_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-node-em-)
* [_pod_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-pod-em-)
* [**CLUSTER MANAGEMENT**](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-strong-cluster-management-strong-)
* [api-versions](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#api-versions)
* [api-resources](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#api-resources)
* [certificate](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#certificate)
* [_approve_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-approve-em-)
* [_deny_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-deny-em-)
* [cluster-info](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#cluster-info)
* [_dump_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-dump-em-)
* [cordon](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#cordon)
* [drain](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#drain)
* [taint](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#taint)
* [uncordon](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#uncordon)
* [**KUBECTL SETTINGS AND USAGE**](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-strong-kubectl-settings-and-usage-strong-)
* [alpha](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#alpha)
* [_auth_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-auth-em-)
* [_auth whoami_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-auth-whoami-em-)
* [completion](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#completion)
* [config](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#config)
* [_current-context_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-current-context-em-)
* [_delete-cluster_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-delete-cluster-em-)
* [_delete-context_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-delete-context-em-)
* [_delete-user_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-delete-user-em-)
* [_get-clusters_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-get-clusters-em-)
* [_get-contexts_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-get-contexts-em-)
* [_get-users_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-get-users-em-)
* [_rename-context_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-rename-context-em-)
* [_set_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-set-em-)
* [_set-cluster_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-set-cluster-em-)
* [_set-context_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-set-context-em-)
* [_set-credentials_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-set-credentials-em-)
* [_unset_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-unset-em-)
* [_use-context_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-use-context-em-)
* [_view_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-view-em-)
* [explain](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#explain)
* [options](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#options)
* [plugin](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#plugin)
* [_list_](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-em-list-em-)
* [version](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#version)
[Copyright 2020 The Kubernetes Authors.](https://github.com/kubernetes/kubernetes)
* example
**GETTING STARTED**
===================
This section contains the most basic commands for getting a workload running on your cluster.
* `run` will start running 1 or more instances of a container image on your cluster.
* `expose` will load balance traffic across the running instances, and can create a HA proxy for accessing the containers from outside the cluster.
Once your workloads are running, you can use the commands in the [WORKING WITH APPS](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#-strong-working-with-apps-strong-)
section to inspect them.
* * *
create
======
> Create a pod using the data in pod.json
kubectl create -f ./pod.json
> Create a pod based on the JSON passed into stdin
cat pod.json | kubectl create -f -
> Edit the data in registry.yaml in JSON then create the resource using the edited data
kubectl create -f registry.yaml --edit -o json
Create a resource from a file or from stdin.
JSON and YAML formats are accepted.
### Usage
`$ kubectl create -f FILENAME`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| edit | | false | Edit the API resource before creating |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files to use to create the resource |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| raw | | | Raw URI to POST to the server. Uses the transport specified by the kubeconfig file. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| windows-line-endings | | false | Only relevant if --edit=true. Defaults to the line ending native to your platform. |
* * *
_clusterrole_
-------------
> Create a cluster role named "pod-reader" that allows user to perform "get", "watch" and "list" on pods
kubectl create clusterrole pod-reader --verb=get,list,watch --resource=pods
> Create a cluster role named "pod-reader" with ResourceName specified
kubectl create clusterrole pod-reader --verb=get --resource=pods --resource-name=readablepod --resource-name=anotherpod
> Create a cluster role named "foo" with API Group specified
kubectl create clusterrole foo --verb=get,list,watch --resource=rs.apps
> Create a cluster role named "foo" with SubResource specified
kubectl create clusterrole foo --verb=get,list,watch --resource=pods,pods/status
> Create a cluster role name "foo" with NonResourceURL specified
kubectl create clusterrole "foo" --verb=get --non-resource-url=/logs/*
> Create a cluster role name "monitoring" with AggregationRule specified
kubectl create clusterrole monitoring --aggregation-rule="rbac.example.com/aggregate-to-monitoring=true"
Create a cluster role.
### Usage
`$ kubectl create clusterrole NAME --verb=verb --resource=resource.group [--resource-name=resourcename] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| aggregation-rule | | | An aggregation label selector for combining ClusterRoles. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| non-resource-url | | \[\] | A partial url that user should have access to. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| resource | | \[\] | Resource that the rule applies to |
| resource-name | | \[\] | Resource in the white list that the rule applies to, repeat this flag for multiple items |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| verb | | \[\] | Verb that applies to the resources contained in the rule |
* * *
_clusterrolebinding_
--------------------
> Create a cluster role binding for user1, user2, and group1 using the cluster-admin cluster role
kubectl create clusterrolebinding cluster-admin --clusterrole=cluster-admin --user=user1 --user=user2 --group=group1
Create a cluster role binding for a particular cluster role.
### Usage
`$ kubectl create clusterrolebinding NAME --clusterrole=NAME [--user=username] [--group=groupname] [--serviceaccount=namespace:serviceaccountname] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| clusterrole | | | ClusterRole this ClusterRoleBinding should reference |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| group | | \[\] | Groups to bind to the clusterrole. The flag can be repeated to add multiple groups. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| serviceaccount | | \[\] | Service accounts to bind to the clusterrole, in the format :. The flag can be repeated to add multiple service accounts. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| user | | \[\] | Usernames to bind to the clusterrole. The flag can be repeated to add multiple users. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_configmap_
-----------
> Create a new config map named my-config based on folder bar
kubectl create configmap my-config --from-file=path/to/bar
> Create a new config map named my-config with specified keys instead of file basenames on disk
kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt
> Create a new config map named my-config with key1=config1 and key2=config2
kubectl create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2
> Create a new config map named my-config from the key=value pairs in the file
kubectl create configmap my-config --from-file=path/to/bar
> Create a new config map named my-config from an env file
kubectl create configmap my-config --from-env-file=path/to/foo.env --from-env-file=path/to/bar.env
Create a config map based on a file, directory, or specified literal value.
A single config map may package one or more key/value pairs.
When creating a config map based on a file, the key will default to the basename of the file, and the value will default to the file content. If the basename is an invalid key, you may specify an alternate key.
When creating a config map based on a directory, each file whose basename is a valid key in the directory will be packaged into the config map. Any directory entries except regular files are ignored (e.g. subdirectories, symlinks, devices, pipes, etc).
### Usage
`$ kubectl create configmap NAME [--from-file=[key=]source] [--from-literal=key1=value1] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| append-hash | | false | Append a hash of the configmap to its name. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| from-env-file | | \[\] | Specify the path to a file to read lines of key=val pairs to create a configmap. |
| from-file | | \[\] | Key file can be specified using its file path, in which case file basename will be used as configmap key, or optionally with a key and file path, in which case the given key will be used. Specifying a directory will iterate each named file in the directory whose basename is a valid configmap key. |
| from-literal | | \[\] | Specify a key and literal value to insert in configmap (i.e. mykey=somevalue) |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_cronjob_
---------
> Create a cron job
kubectl create cronjob my-job --image=busybox --schedule="*/1 * * * *"
> Create a cron job with a command
kubectl create cronjob my-job --image=busybox --schedule="*/1 * * * *" -- date
Create a cron job with the specified name.
### Usage
`$ kubectl create cronjob NAME --image=image --schedule='0/5 * * * ?' -- [COMMAND] [args...]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| image | | | Image name to run. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| restart | | | job's restart policy. supported values: OnFailure, Never |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| schedule | | | A schedule in the Cron format the job should be run with. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_deployment_
------------
> Create a deployment named my-dep that runs the busybox image
kubectl create deployment my-dep --image=busybox
> Create a deployment with a command
kubectl create deployment my-dep --image=busybox -- date
> Create a deployment named my-dep that runs the nginx image with 3 replicas
kubectl create deployment my-dep --image=nginx --replicas=3
> Create a deployment named my-dep that runs the busybox image and expose port 5701
kubectl create deployment my-dep --image=busybox --port=5701
Create a deployment with the specified name.
### Usage
`$ kubectl create deployment NAME --image=image -- [COMMAND] [args...]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| image | | \[\] | Image names to run. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| port | | \-1 | The port that this container exposes. |
| replicas | r | 1 | Number of replicas to create. Default is 1. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_ingress_
---------
> Create a single ingress called 'simple' that directs requests to foo.com/bar to svc # svc1:8080 with a tls secret "my-cert"
kubectl create ingress simple --rule="foo.com/bar=svc1:8080,tls=my-cert"
> Create a catch all ingress of "/path" pointing to service svc:port and Ingress Class as "otheringress"
kubectl create ingress catch-all --class=otheringress --rule="/path=svc:port"
> Create an ingress with two annotations: ingress.annotation1 and ingress.annotations2
kubectl create ingress annotated --class=default --rule="foo.com/bar=svc:port" \
--annotation ingress.annotation1=foo \
--annotation ingress.annotation2=bla
> Create an ingress with the same host and multiple paths
kubectl create ingress multipath --class=default \
--rule="foo.com/=svc:port" \
--rule="foo.com/admin/=svcadmin:portadmin"
> Create an ingress with multiple hosts and the pathType as Prefix
kubectl create ingress ingress1 --class=default \
--rule="foo.com/path*=svc:8080" \
--rule="bar.com/admin*=svc2:http"
> Create an ingress with TLS enabled using the default ingress certificate and different path types
kubectl create ingress ingtls --class=default \
--rule="foo.com/=svc:https,tls" \
--rule="foo.com/path/subpath*=othersvc:8080"
> Create an ingress with TLS enabled using a specific secret and pathType as Prefix
kubectl create ingress ingsecret --class=default \
--rule="foo.com/*=svc:8080,tls=secret1"
> Create an ingress with a default backend
kubectl create ingress ingdefault --class=default \
--default-backend=defaultsvc:http \
--rule="foo.com/*=svc:8080,tls=secret1"
Create an ingress with the specified name.
### Usage
`$ kubectl create ingress NAME --rule=host/path=service:port[,tls[=secret]]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| annotation | | \[\] | Annotation to insert in the ingress object, in the format annotation=value |
| class | | | Ingress Class to be used |
| default-backend | | | Default service for backend, in format of svcname:port |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| rule | | \[\] | Rule in format host/path=service:port\[,tls=secretname\]. Paths containing the leading character '\*' are considered pathType=Prefix. tls argument is optional. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_job_
-----
> Create a job
kubectl create job my-job --image=busybox
> Create a job with a command
kubectl create job my-job --image=busybox -- date
> Create a job from a cron job named "a-cronjob"
kubectl create job test-job --from=cronjob/a-cronjob
Create a job with the specified name.
### Usage
`$ kubectl create job NAME --image=image [--from=cronjob/name] -- [COMMAND] [args...]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| from | | | The name of the resource to create a Job from (only cronjob is supported). |
| image | | | Image name to run. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_namespace_
-----------
> Create a new namespace named my-namespace
kubectl create namespace my-namespace
Create a namespace with the specified name.
### Usage
`$ kubectl create namespace NAME [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_poddisruptionbudget_
---------------------
> Create a pod disruption budget named my-pdb that will select all pods with the app=rails label # and require at least one of them being available at any point in time
kubectl create poddisruptionbudget my-pdb --selector=app=rails --min-available=1
> Create a pod disruption budget named my-pdb that will select all pods with the app=nginx label # and require at least half of the pods selected to be available at any point in time
kubectl create pdb my-pdb --selector=app=nginx --min-available=50%
Create a pod disruption budget with the specified name, selector, and desired minimum available pods.
### Usage
`$ kubectl create poddisruptionbudget NAME --selector=SELECTOR --min-available=N [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| max-unavailable | | | The maximum number or percentage of unavailable pods this budget requires. |
| min-available | | | The minimum number or percentage of available pods this budget requires. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| selector | | | A label selector to use for this budget. Only equality-based selector requirements are supported. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_priorityclass_
---------------
> Create a priority class named high-priority
kubectl create priorityclass high-priority --value=1000 --description="high priority"
> Create a priority class named default-priority that is considered as the global default priority
kubectl create priorityclass default-priority --value=1000 --global-default=true --description="default priority"
> Create a priority class named high-priority that cannot preempt pods with lower priority
kubectl create priorityclass high-priority --value=1000 --description="high priority" --preemption-policy="Never"
Create a priority class with the specified name, value, globalDefault and description.
### Usage
`$ kubectl create priorityclass NAME --value=VALUE --global-default=BOOL [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| description | | | description is an arbitrary string that usually provides guidelines on when this priority class should be used. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| global-default | | false | global-default specifies whether this PriorityClass should be considered as the default priority. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| preemption-policy | | PreemptLowerPriority | preemption-policy is the policy for preempting pods with lower priority. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| value | | 0 | the value of this priority class. |
* * *
_quota_
-------
> Create a new resource quota named my-quota
kubectl create quota my-quota --hard=cpu=1,memory=1G,pods=2,services=3,replicationcontrollers=2,resourcequotas=1,secrets=5,persistentvolumeclaims=10
> Create a new resource quota named best-effort
kubectl create quota best-effort --hard=pods=100 --scopes=BestEffort
Create a resource quota with the specified name, hard limits, and optional scopes.
### Usage
`$ kubectl create quota NAME [--hard=key1=value1,key2=value2] [--scopes=Scope1,Scope2] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| hard | | | A comma-delimited set of resource=quantity pairs that define a hard limit. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| scopes | | | A comma-delimited set of quota scopes that must all match each object tracked by the quota. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_role_
------
> Create a role named "pod-reader" that allows user to perform "get", "watch" and "list" on pods
kubectl create role pod-reader --verb=get --verb=list --verb=watch --resource=pods
> Create a role named "pod-reader" with ResourceName specified
kubectl create role pod-reader --verb=get --resource=pods --resource-name=readablepod --resource-name=anotherpod
> Create a role named "foo" with API Group specified
kubectl create role foo --verb=get,list,watch --resource=rs.apps
> Create a role named "foo" with SubResource specified
kubectl create role foo --verb=get,list,watch --resource=pods,pods/status
Create a role with single rule.
### Usage
`$ kubectl create role NAME --verb=verb --resource=resource.group/subresource [--resource-name=resourcename] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| resource | | \[\] | Resource that the rule applies to |
| resource-name | | \[\] | Resource in the white list that the rule applies to, repeat this flag for multiple items |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| verb | | \[\] | Verb that applies to the resources contained in the rule |
* * *
_rolebinding_
-------------
> Create a role binding for user1, user2, and group1 using the admin cluster role
kubectl create rolebinding admin --clusterrole=admin --user=user1 --user=user2 --group=group1
Create a role binding for a particular role or cluster role.
### Usage
`$ kubectl create rolebinding NAME --clusterrole=NAME|--role=NAME [--user=username] [--group=groupname] [--serviceaccount=namespace:serviceaccountname] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| clusterrole | | | ClusterRole this RoleBinding should reference |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| group | | \[\] | Groups to bind to the role. The flag can be repeated to add multiple groups. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| role | | | Role this RoleBinding should reference |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| serviceaccount | | \[\] | Service accounts to bind to the role, in the format :. The flag can be repeated to add multiple service accounts. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| user | | \[\] | Usernames to bind to the role. The flag can be repeated to add multiple users. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_secret_
--------
Create a secret using specified subcommand.
### Usage
`$ kubectl create secret`
* * *
_secret docker-registry_
------------------------
> If you don't already have a .dockercfg file, you can create a dockercfg secret directly by using:
kubectl create secret docker-registry my-secret --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL
> Create a new secret named my-secret from ~/.docker/config.json
kubectl create secret docker-registry my-secret --from-file=.dockerconfigjson=path/to/.docker/config.json
Create a new secret for use with Docker registries.
Dockercfg secrets are used to authenticate against Docker registries.
When using the Docker command line to push images, you can authenticate to a given registry by running: '$ docker login DOCKER\_REGISTRY\_SERVER --username=DOCKER\_USER --password=DOCKER\_PASSWORD --email=DOCKER\_EMAIL'.
That produces a ~/.dockercfg file that is used by subsequent 'docker push' and 'docker pull' commands to authenticate to the registry. The email address is optional.
When creating applications, you may have a Docker registry that requires authentication. In order for the nodes to pull images on your behalf, they must have the credentials. You can provide this information by creating a dockercfg secret and attaching it to your service account.
### Usage
`$ kubectl create secret docker-registry NAME --docker-username=user --docker-password=password --docker-email=email [--docker-server=string] [--from-file=[key=]source] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| append-hash | | false | Append a hash of the secret to its name. |
| docker-email | | | Email for Docker registry |
| docker-password | | | Password for Docker registry authentication |
| docker-server | | [https://index.docker.io/v1/](https://index.docker.io/v1/) | Server location for Docker registry |
| docker-username | | | Username for Docker registry authentication |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| from-file | | \[\] | Key files can be specified using their file path, in which case a default name will be given to them, or optionally with a name and file path, in which case the given name will be used. Specifying a directory will iterate each named file in the directory that is a valid secret key. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_secret generic_
----------------
> Create a new secret named my-secret with keys for each file in folder bar
kubectl create secret generic my-secret --from-file=path/to/bar
> Create a new secret named my-secret with specified keys instead of names on disk
kubectl create secret generic my-secret --from-file=ssh-privatekey=path/to/id_rsa --from-file=ssh-publickey=path/to/id_rsa.pub
> Create a new secret named my-secret with key1=supersecret and key2=topsecret
kubectl create secret generic my-secret --from-literal=key1=supersecret --from-literal=key2=topsecret
> Create a new secret named my-secret using a combination of a file and a literal
kubectl create secret generic my-secret --from-file=ssh-privatekey=path/to/id_rsa --from-literal=passphrase=topsecret
> Create a new secret named my-secret from env files
kubectl create secret generic my-secret --from-env-file=path/to/foo.env --from-env-file=path/to/bar.env
Create a secret based on a file, directory, or specified literal value.
A single secret may package one or more key/value pairs.
When creating a secret based on a file, the key will default to the basename of the file, and the value will default to the file content. If the basename is an invalid key or you wish to chose your own, you may specify an alternate key.
When creating a secret based on a directory, each file whose basename is a valid key in the directory will be packaged into the secret. Any directory entries except regular files are ignored (e.g. subdirectories, symlinks, devices, pipes, etc).
### Usage
`$ kubectl create secret generic NAME [--type=string] [--from-file=[key=]source] [--from-literal=key1=value1] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| append-hash | | false | Append a hash of the secret to its name. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| from-env-file | | \[\] | Specify the path to a file to read lines of key=val pairs to create a secret. |
| from-file | | \[\] | Key files can be specified using their file path, in which case a default name will be given to them, or optionally with a name and file path, in which case the given name will be used. Specifying a directory will iterate each named file in the directory that is a valid secret key. |
| from-literal | | \[\] | Specify a key and literal value to insert in secret (i.e. mykey=somevalue) |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| type | | | The type of secret to create |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_secret tls_
------------
> Create a new TLS secret named tls-secret with the given key pair
kubectl create secret tls tls-secret --cert=path/to/tls.cert --key=path/to/tls.key
Create a TLS secret from the given public/private key pair.
The public/private key pair must exist beforehand. The public key certificate must be .PEM encoded and match the given private key.
### Usage
`$ kubectl create secret tls NAME --cert=path/to/cert/file --key=path/to/key/file [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| append-hash | | false | Append a hash of the secret to its name. |
| cert | | | Path to PEM encoded public key certificate. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| key | | | Path to private key associated with given certificate. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_service_
---------
Create a service using a specified subcommand.
### Usage
`$ kubectl create service`
* * *
_service clusterip_
-------------------
> Create a new ClusterIP service named my-cs
kubectl create service clusterip my-cs --tcp=5678:8080
> Create a new ClusterIP service named my-cs (in headless mode)
kubectl create service clusterip my-cs --clusterip="None"
Create a ClusterIP service with the specified name.
### Usage
`$ kubectl create service clusterip NAME [--tcp=:] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| clusterip | | | Assign your own ClusterIP or set to 'None' for a 'headless' service (no loadbalancing). |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| tcp | | \[\] | Port pairs can be specified as ':'. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_service externalname_
----------------------
> Create a new ExternalName service named my-ns
kubectl create service externalname my-ns --external-name bar.com
Create an ExternalName service with the specified name.
ExternalName service references to an external DNS address instead of only pods, which will allow application authors to reference services that exist off platform, on other clusters, or locally.
### Usage
`$ kubectl create service externalname NAME --external-name external.name [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| external-name | | | External name of service |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| tcp | | \[\] | Port pairs can be specified as ':'. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_service loadbalancer_
----------------------
> Create a new LoadBalancer service named my-lbs
kubectl create service loadbalancer my-lbs --tcp=5678:8080
Create a LoadBalancer service with the specified name.
### Usage
`$ kubectl create service loadbalancer NAME [--tcp=port:targetPort] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| tcp | | \[\] | Port pairs can be specified as ':'. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_service nodeport_
------------------
> Create a new NodePort service named my-ns
kubectl create service nodeport my-ns --tcp=5678:8080
Create a NodePort service with the specified name.
### Usage
`$ kubectl create service nodeport NAME [--tcp=port:targetPort] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| node-port | | 0 | Port used to expose the service on each node in a cluster. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| tcp | | \[\] | Port pairs can be specified as ':'. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_serviceaccount_
----------------
> Create a new service account named my-service-account
kubectl create serviceaccount my-service-account
Create a service account with the specified name.
### Usage
`$ kubectl create serviceaccount NAME [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-create | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
_token_
-------
> Request a token to authenticate to the kube-apiserver as the service account "myapp" in the current namespace
kubectl create token myapp
> Request a token for a service account in a custom namespace
kubectl create token myapp --namespace myns
> Request a token with a custom expiration
kubectl create token myapp --duration 10m
> Request a token with a custom audience
kubectl create token myapp --audience https://example.com
> Request a token bound to an instance of a Secret object
kubectl create token myapp --bound-object-kind Secret --bound-object-name mysecret
> Request a token bound to an instance of a Secret object with a specific uid
kubectl create token myapp --bound-object-kind Secret --bound-object-name mysecret --bound-object-uid 0d4691ed-659b-4935-a832-355f77ee47cc
Request a service account token.
### Usage
`$ kubectl create token SERVICE_ACCOUNT_NAME`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| audience | | \[\] | Audience of the requested token. If unset, defaults to requesting a token for use with the Kubernetes API server. May be repeated to request a token valid for multiple audiences. |
| bound-object-kind | | | Kind of an object to bind the token to. Supported kinds are Pod, Secret. If set, --bound-object-name must be provided. |
| bound-object-name | | | Name of an object to bind the token to. The token will expire when the object is deleted. Requires --bound-object-kind. |
| bound-object-uid | | | UID of an object to bind the token to. Requires --bound-object-kind and --bound-object-name. If unset, the UID of the existing object is used. |
| duration | | 0s | Requested lifetime of the issued token. The server may return a token with a longer or shorter lifetime. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
get
===
> List all pods in ps output format
kubectl get pods
> List all pods in ps output format with more information (such as node name)
kubectl get pods -o wide
> List a single replication controller with specified NAME in ps output format
kubectl get replicationcontroller web
> List deployments in JSON output format, in the "v1" version of the "apps" API group
kubectl get deployments.v1.apps -o json
> List a single pod in JSON output format
kubectl get -o json pod web-pod-13je7
> List a pod identified by type and name specified in "pod.yaml" in JSON output format
kubectl get -f pod.yaml -o json
> List resources from a directory with kustomization.yaml - e.g. dir/kustomization.yaml
kubectl get -k dir/
> Return only the phase value of the specified pod
kubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}
> List resource information in custom columns
kubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0].name,IMAGE:.spec.containers[0].image
> List all replication controllers and services together in ps output format
kubectl get rc,services
> List one or more resources by their type and names
kubectl get rc/web service/frontend pods/web-pod-13je7
> List status subresource for a single pod.
kubectl get pod web-pod-13je7 --subresource status
Display one or many resources.
Prints a table of the most important information about the specified resources. You can filter the list using a label selector and the --selector flag. If the desired resource type is namespaced you will only see results in your current namespace unless you pass --all-namespaces.
By specifying the output as 'template' and providing a Go template as the value of the --template flag, you can filter the attributes of the fetched resources.
Use "kubectl api-resources" for a complete list of supported resources.
### Usage
`$ kubectl get [(-o|--output=)json|yaml|name|go-template|go-template-file|template|templatefile|jsonpath|jsonpath-as-json|jsonpath-file|custom-columns|custom-columns-file|wide] (TYPE[.VERSION][.GROUP] [NAME | -l label] | TYPE[.VERSION][.GROUP]/NAME ...) [flags]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-namespaces | A | false | If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| chunk-size | | 500 | Return large lists in chunks rather than all at once. Pass 0 to disable. This flag is beta and may change in the future. |
| field-selector | | | Selector (field query) to filter on, supports '=', '==', and '!='.(e.g. --field-selector key1=value1,key2=value2). The server only supports a limited number of field queries per type. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| ignore-not-found | | false | If the requested object does not exist the command will return exit code 0. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| label-columns | L | \[\] | Accepts a comma separated list of labels that are going to be presented as columns. Names are case-sensitive. You can also use multiple flag options like -L label1 -L label2... |
| no-headers | | false | When using the default or custom-column output format, don't print headers (default print headers). |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file, custom-columns, custom-columns-file, wide). See custom columns \[[https://kubernetes.io/docs/reference/kubectl/#custom-columns](https://kubernetes.io/docs/reference/kubectl/#custom-columns) \], golang template \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \] and jsonpath template \[[https://kubernetes.io/docs/reference/kubectl/jsonpath/](https://kubernetes.io/docs/reference/kubectl/jsonpath/) \]. |
| output-watch-events | | false | Output watch event objects when --watch or --watch-only is used. Existing objects are output as initial ADDED events. |
| raw | | | Raw URI to request from the server. Uses the transport specified by the kubeconfig file. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| server-print | | true | If true, have the server return the appropriate table output. Supports extension APIs and CRDs. |
| show-kind | | false | If present, list the resource type for the requested object(s). |
| show-labels | | false | When printing, show all labels as the last column (default hide labels column) |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| sort-by | | | If non-empty, sort list types using this field specification. The field specification is expressed as a JSONPath expression (e.g. '{.metadata.name}'). The field in the API resource specified by this JSONPath expression must be an integer or a string. |
| subresource | | | If specified, gets the subresource of the requested object. Must be one of \[status scale\]. This flag is alpha and may change in the future. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| use-openapi-print-columns | | false | If true, use x-kubernetes-print-column metadata (if present) from the OpenAPI schema for displaying a resource. |
| watch | w | false | After listing/getting the requested object, watch for changes. |
| watch-only | | false | Watch for changes to the requested object(s), without listing/getting first. |
* * *
run
===
> Start a nginx pod
kubectl run nginx --image=nginx
> Start a hazelcast pod and let the container expose port 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701
> Start a hazelcast pod and set environment variables "DNS\_DOMAIN=cluster" and "POD\_NAMESPACE=default" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"
> Start a hazelcast pod and set labels "app=hazelcast" and "env=prod" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"
> Dry run; print the corresponding API objects without creating them
kubectl run nginx --image=nginx --dry-run=client
> Start a nginx pod, but overload the spec with a partial set of values parsed from JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'
> Start a busybox pod and keep it in the foreground, don't restart it if it exits
kubectl run -i -t busybox --image=busybox --restart=Never
> Start the nginx pod using the default command, but use custom arguments (arg1 .. argN) for that command
kubectl run nginx --image=nginx -- ...
> Start the nginx pod using a different command and custom arguments
kubectl run nginx --image=nginx --command -- ...
Create and run a particular image in a pod.
### Usage
`$ kubectl run NAME --image=image [--env="key=value"] [--port=port] [--dry-run=server|client] [--overrides=inline-json] [--command] -- [COMMAND] [args...]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| annotations | | \[\] | Annotations to apply to the pod. |
| attach | | false | If true, wait for the Pod to start running, and then attach to the Pod as if 'kubectl attach ...' were called. Default false, unless '-i/--stdin' is set, in which case the default is true. With '--restart=Never' the exit code of the container process is returned. |
| cascade | | background | Must be "background", "orphan", or "foreground". Selects the deletion cascading strategy for the dependents (e.g. Pods created by a ReplicationController). Defaults to background. |
| command | | false | If true and extra arguments are present, use them as the 'command' field in the container, rather than the 'args' field which is the default. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| env | | \[\] | Environment variables to set in the container. |
| expose | | false | If true, create a ClusterIP service associated with the pod. Requires `--port`. |
| field-manager | | kubectl-run | Name of the manager used to track field ownership. |
| filename | f | \[\] | to use to replace the resource. |
| force | | false | If true, immediately remove resources from API and bypass graceful deletion. Note that immediate deletion of some resources may result in inconsistency or data loss and requires confirmation. |
| grace-period | | \-1 | Period of time in seconds given to the resource to terminate gracefully. Ignored if negative. Set to 1 for immediate shutdown. Can only be set to 0 when --force is true (force deletion). |
| image | | | The image for the container to run. |
| image-pull-policy | | | The image pull policy for the container. If left empty, this value will not be specified by the client and defaulted by the server. |
| kustomize | k | | Process a kustomization directory. This flag can't be used together with -f or -R. |
| labels | l | | Comma separated labels to apply to the pod. Will override previous values. |
| leave-stdin-open | | false | If the pod is started in interactive mode or with stdin, leave stdin open after the first attach completes. By default, stdin will be closed after the first attach completes. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| override-type | | merge | The method used to override the generated object: json, merge, or strategic. |
| overrides | | | An inline JSON override for the generated object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field. |
| pod-running-timeout | | 1m0s | The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running |
| port | | | The port that this container exposes. |
| privileged | | false | If true, run the container in privileged mode. |
| quiet | q | false | If true, suppress prompt messages. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| restart | | Always | The restart policy for this Pod. Legal values \[Always, OnFailure, Never\]. |
| rm | | false | If true, delete the pod after it exits. Only valid when attaching to the container, e.g. with '--attach' or with '-i/--stdin'. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| stdin | i | false | Keep stdin open on the container in the pod, even if nothing is attached. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| timeout | | 0s | The length of time to wait before giving up on a delete, zero means determine a timeout from the size of the object |
| tty | t | false | Allocate a TTY for the container in the pod. |
| wait | | false | If true, wait for resources to be gone before returning. This waits for finalizers. |
* * *
expose
======
> Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000
kubectl expose rc nginx --port=80 --target-port=8000
> Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml", which serves on port 80 and connects to the containers on port 8000
kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000
> Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
kubectl expose pod valid-pod --port=444 --name=frontend
> Create a second service based on the above service, exposing the container port 8443 as port 443 with the name "nginx-https"
kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
> Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
kubectl expose rc streamer --port=4100 --protocol=UDP --name=video-stream
> Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on port 8000
kubectl expose rs nginx --port=80 --target-port=8000
> Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000
kubectl expose deployment nginx --port=80 --target-port=8000
Expose a resource as a new Kubernetes service.
Looks up a deployment, service, replica set, replication controller or pod by name and uses the selector for that resource as the selector for a new service on the specified port. A deployment or replica set will be exposed as a service only if its selector is convertible to a selector that service supports, i.e. when the selector contains only the matchLabels component. Note that if no port is specified via --port and the exposed resource has multiple ports, all will be re-used by the new service. Also if no labels are specified, the new service will re-use the labels from the resource it exposes.
Possible resources include (case insensitive):
pod (po), service (svc), replicationcontroller (rc), deployment (deploy), replicaset (rs)
### Usage
`$ kubectl expose (-f FILENAME | TYPE NAME) [--port=port] [--protocol=TCP|UDP|SCTP] [--target-port=number-or-name] [--name=name] [--external-ip=external-ip-of-service] [--type=type]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| cluster-ip | | | ClusterIP to be assigned to the service. Leave empty to auto-allocate, or set to 'None' to create a headless service. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| external-ip | | | Additional external IP address (not managed by Kubernetes) to accept for the service. If this IP is routed to a node, the service can be accessed by this IP in addition to its generated service IP. |
| field-manager | | kubectl-expose | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to expose a service |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| labels | l | | Labels to apply to the service created by this call. |
| load-balancer-ip | | | IP to assign to the LoadBalancer. If empty, an ephemeral IP will be created and used (cloud-provider specific). |
| name | | | The name for the newly created object. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| override-type | | merge | The method used to override the generated object: json, merge, or strategic. |
| overrides | | | An inline JSON override for the generated object. If this is non-empty, it is used to override the generated object. Requires that the object supply a valid apiVersion field. |
| port | | | The port that the service should serve on. Copied from the resource being exposed, if unspecified |
| protocol | | | The network protocol for the service to be created. Default is 'TCP'. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| selector | | | A label selector to use for this service. Only equality-based selector requirements are supported. If empty (the default) infer the selector from the replication controller or replica set.) |
| session-affinity | | | If non-empty, set the session affinity for the service to this; legal values: 'None', 'ClientIP' |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| target-port | | | Name or number for the port on the container that the service should direct traffic to. Optional. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| type | | | Type for this service: ClusterIP, NodePort, LoadBalancer, or ExternalName. Default is 'ClusterIP'. |
* * *
delete
======
> Delete a pod using the type and name specified in pod.json
kubectl delete -f ./pod.json
> Delete resources from a directory containing kustomization.yaml - e.g. dir/kustomization.yaml
kubectl delete -k dir
> Delete resources from all files that end with '.json' - i.e. expand wildcard characters in file names
kubectl delete -f '*.json'
> Delete a pod based on the type and name in the JSON passed into stdin
cat pod.json | kubectl delete -f -
> Delete pods and services with same names "baz" and "foo"
kubectl delete pod,service baz foo
> Delete pods and services with label name=myLabel
kubectl delete pods,services -l name=myLabel
> Delete a pod with minimal delay
kubectl delete pod foo --now
> Force delete a pod on a dead node
kubectl delete pod foo --force
> Delete all pods
kubectl delete pods --all
Delete resources by file names, stdin, resources and names, or by resources and label selector.
JSON and YAML formats are accepted. Only one type of argument may be specified: file names, resources and names, or resources and label selector.
Some resources, such as pods, support graceful deletion. These resources define a default period before they are forcibly terminated (the grace period) but you may override that value with the --grace-period flag, or pass --now to set a grace-period of 1. Because these resources often represent entities in the cluster, deletion may not be acknowledged immediately. If the node hosting a pod is down or cannot reach the API server, termination may take significantly longer than the grace period. To force delete a resource, you must specify the --force flag. Note: only a subset of resources support graceful deletion. In absence of the support, the --grace-period flag is ignored.
IMPORTANT: Force deleting pods does not wait for confirmation that the pod's processes have been terminated, which can leave those processes running until the node detects the deletion and completes graceful deletion. If your processes use shared storage or talk to a remote API and depend on the name of the pod to identify themselves, force deleting those pods may result in multiple processes running on different machines using the same identification which may lead to data corruption or inconsistency. Only force delete pods when you are sure the pod is terminated, or if your application can tolerate multiple copies of the same pod running at once. Also, if you force delete pods, the scheduler may place new pods on those nodes before the node has released those resources and causing those pods to be evicted immediately.
Note that the delete command does NOT do resource version checks, so if someone submits an update to a resource right when you submit a delete, their update will be lost along with the rest of the resource.
After a CustomResourceDefinition is deleted, invalidation of discovery cache may take up to 6 hours. If you don't want to wait, you might want to run "kubectl api-resources" to refresh the discovery cache.
### Usage
`$ kubectl delete ([-f FILENAME] | [-k DIRECTORY] | TYPE [(NAME | -l label | --all)])`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Delete all resources, in the namespace of the specified resource types. |
| all-namespaces | A | false | If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace. |
| cascade | | background | Must be "background", "orphan", or "foreground". Selects the deletion cascading strategy for the dependents (e.g. Pods created by a ReplicationController). Defaults to background. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-selector | | | Selector (field query) to filter on, supports '=', '==', and '!='.(e.g. --field-selector key1=value1,key2=value2). The server only supports a limited number of field queries per type. |
| filename | f | \[\] | containing the resource to delete. |
| force | | false | If true, immediately remove resources from API and bypass graceful deletion. Note that immediate deletion of some resources may result in inconsistency or data loss and requires confirmation. |
| grace-period | | \-1 | Period of time in seconds given to the resource to terminate gracefully. Ignored if negative. Set to 1 for immediate shutdown. Can only be set to 0 when --force is true (force deletion). |
| ignore-not-found | | false | Treat "resource not found" as a successful delete. Defaults to "true" when --all is specified. |
| kustomize | k | | Process a kustomization directory. This flag can't be used together with -f or -R. |
| now | | false | If true, resources are signaled for immediate shutdown (same as --grace-period=1). |
| output | o | | Output mode. Use "-o name" for shorter output (resource/name). |
| raw | | | Raw URI to DELETE to the server. Uses the transport specified by the kubeconfig file. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| timeout | | 0s | The length of time to wait before giving up on a delete, zero means determine a timeout from the size of the object |
| wait | | true | If true, wait for resources to be gone before returning. This waits for finalizers. |
**APP MANAGEMENT**
==================
This section contains commands for creating, updating, deleting, and viewing your workloads in a Kubernetes cluster.
* * *
apply
=====
> Apply the configuration in pod.json to a pod
kubectl apply -f ./pod.json
> Apply resources from a directory containing kustomization.yaml - e.g. dir/kustomization.yaml
kubectl apply -k dir/
> Apply the JSON passed into stdin to a pod
cat pod.json | kubectl apply -f -
> Apply the configuration from all files that end with '.json' - i.e. expand wildcard characters in file names
kubectl apply -f '*.json'
> Note: --prune is still in Alpha # Apply the configuration in manifest.yaml that matches label app=nginx and delete all other resources that are not in the file and match label app=nginx
kubectl apply --prune -f manifest.yaml -l app=nginx
> Apply the configuration in manifest.yaml and delete all the other config maps that are not in the file
kubectl apply --prune -f manifest.yaml --all --prune-allowlist=core/v1/ConfigMap
Apply a configuration to a resource by file name or stdin. The resource name must be specified. This resource will be created if it doesn't exist yet. To use 'apply', always create the resource initially with either 'apply' or 'create --save-config'.
JSON and YAML formats are accepted.
Alpha Disclaimer: the --prune functionality is not yet complete. Do not use unless you are aware of what the current state is. See [https://issues.k8s.io/34274](https://issues.k8s.io/34274)
.
### Usage
`$ kubectl apply (-f FILENAME | -k DIRECTORY)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources in the namespace of the specified resource types. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| cascade | | background | Must be "background", "orphan", or "foreground". Selects the deletion cascading strategy for the dependents (e.g. Pods created by a ReplicationController). Defaults to background. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-client-side-apply | Name of the manager used to track field ownership. |
| filename | f | \[\] | The files that contain the configurations to apply. |
| force | | false | If true, immediately remove resources from API and bypass graceful deletion. Note that immediate deletion of some resources may result in inconsistency or data loss and requires confirmation. |
| force-conflicts | | false | If true, server-side apply will force the changes against conflicts. |
| grace-period | | \-1 | Period of time in seconds given to the resource to terminate gracefully. Ignored if negative. Set to 1 for immediate shutdown. Can only be set to 0 when --force is true (force deletion). |
| kustomize | k | | Process a kustomization directory. This flag can't be used together with -f or -R. |
| openapi-patch | | true | If true, use openapi to calculate diff when the openapi presents and the resource can be found in the openapi spec. Otherwise, fall back to use baked-in types. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| overwrite | | true | Automatically resolve conflicts between the modified and live configuration by using values from the modified configuration |
| prune | | false | Automatically delete resource objects, that do not appear in the configs and are created by either apply or create --save-config. Should be used with either -l or --all. |
| prune-allowlist | | \[\] | Overwrite the default allowlist with for --prune |
| prune-whitelist | | \[\] | Overwrite the default whitelist with for --prune |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| server-side | | false | If true, apply runs in the server instead of the client. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| timeout | | 0s | The length of time to wait before giving up on a delete, zero means determine a timeout from the size of the object |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| wait | | false | If true, wait for resources to be gone before returning. This waits for finalizers. |
* * *
_edit-last-applied_
-------------------
> Edit the last-applied-configuration annotations by type/name in YAML
kubectl apply edit-last-applied deployment/nginx
> Edit the last-applied-configuration annotations by file in JSON
kubectl apply edit-last-applied -f deploy.yaml -o json
Edit the latest last-applied-configuration annotations of resources from the default editor.
The edit-last-applied command allows you to directly edit any API resource you can retrieve via the command-line tools. It will open the editor defined by your KUBE\_EDITOR, or EDITOR environment variables, or fall back to 'vi' for Linux or 'notepad' for Windows. You can edit multiple objects, although changes are applied one at a time. The command accepts file names as well as command-line arguments, although the files you point to must be previously saved versions of resources.
The default format is YAML. To edit in JSON, specify "-o json".
The flag --windows-line-endings can be used to force Windows line endings, otherwise the default for your operating system will be used.
In the event an error occurs while updating, a temporary file will be created on disk that contains your unapplied changes. The most common error when updating a resource is another editor changing the resource on the server. When this occurs, you will have to apply your changes to the newer version of the resource, or update your temporary saved copy to include the latest resource version.
### Usage
`$ kubectl apply edit-last-applied (RESOURCE/NAME | -f FILENAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| field-manager | | kubectl-client-side-apply | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files to use to edit the resource |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| windows-line-endings | | false | Defaults to the line ending native to your platform. |
* * *
_set-last-applied_
------------------
> Set the last-applied-configuration of a resource to match the contents of a file
kubectl apply set-last-applied -f deploy.yaml
> Execute set-last-applied against each configuration file in a directory
kubectl apply set-last-applied -f path/
> Set the last-applied-configuration of a resource to match the contents of a file; will create the annotation if it does not already exist
kubectl apply set-last-applied -f deploy.yaml --create-annotation=true
Set the latest last-applied-configuration annotations by setting it to match the contents of a file. This results in the last-applied-configuration being updated as though 'kubectl apply -f ' was run, without updating any other parts of the object.
### Usage
`$ kubectl apply set-last-applied -f FILENAME`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| create-annotation | | false | Will create 'last-applied-configuration' annotations if current objects doesn't have one |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| filename | f | \[\] | Filename, directory, or URL to files that contains the last-applied-configuration annotations |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_view-last-applied_
-------------------
> View the last-applied-configuration annotations by type/name in YAML
kubectl apply view-last-applied deployment/nginx
> View the last-applied-configuration annotations by file in JSON
kubectl apply view-last-applied -f deploy.yaml -o json
View the latest last-applied-configuration annotations by type/name or file.
The default output will be printed to stdout in YAML format. You can use the -o option to change the output format.
### Usage
`$ kubectl apply view-last-applied (TYPE [NAME | -l label] | TYPE/NAME | -f FILENAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources in the namespace of the specified resource types |
| filename | f | \[\] | Filename, directory, or URL to files that contains the last-applied-configuration annotations |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | yaml | Output format. Must be one of (yaml, json) |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
* * *
annotate
========
> Update pod 'foo' with the annotation 'description' and the value 'my frontend' # If the same annotation is set multiple times, only the last value will be applied
kubectl annotate pods foo description='my frontend'
> Update a pod identified by type and name in "pod.json"
kubectl annotate -f pod.json description='my frontend'
> Update pod 'foo' with the annotation 'description' and the value 'my frontend running nginx', overwriting any existing value
kubectl annotate --overwrite pods foo description='my frontend running nginx'
> Update all pods in the namespace
kubectl annotate pods --all description='my frontend running nginx'
> Update pod 'foo' only if the resource is unchanged from version 1
kubectl annotate pods foo description='my frontend running nginx' --resource-version=1
> Update pod 'foo' by removing an annotation named 'description' if it exists # Does not require the --overwrite flag
kubectl annotate pods foo description-
Update the annotations on one or more resources.
All Kubernetes objects support the ability to store additional data with the object as annotations. Annotations are key/value pairs that can be larger than labels and include arbitrary string values such as structured JSON. Tools and system extensions may use annotations to store their own data.
Attempting to set an annotation that already exists will fail unless --overwrite is set. If --resource-version is specified and does not match the current resource version on the server the command will fail.
Use "kubectl api-resources" for a complete list of supported resources.
### Usage
`$ kubectl annotate [--overwrite] (-f FILENAME | TYPE NAME) KEY_1=VAL_1 ... KEY_N=VAL_N [--resource-version=version]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources, in the namespace of the specified resource types. |
| all-namespaces | A | false | If true, check the specified action in all namespaces. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-annotate | Name of the manager used to track field ownership. |
| field-selector | | | Selector (field query) to filter on, supports '=', '==', and '!='.(e.g. --field-selector key1=value1,key2=value2). The server only supports a limited number of field queries per type. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to update the annotation |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| list | | false | If true, display the annotations for a given resource. |
| local | | false | If true, annotation will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| overwrite | | false | If true, allow annotations to be overwritten, otherwise reject annotation updates that overwrite existing annotations. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| resource-version | | | If non-empty, the annotation update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
autoscale
=========
> Auto scale a deployment "foo", with the number of pods between 2 and 10, no target CPU utilization specified so a default autoscaling policy will be used
kubectl autoscale deployment foo --min=2 --max=10
> Auto scale a replication controller "foo", with the number of pods between 1 and 5, target CPU utilization at 80%
kubectl autoscale rc foo --max=5 --cpu-percent=80
Creates an autoscaler that automatically chooses and sets the number of pods that run in a Kubernetes cluster.
Looks up a deployment, replica set, stateful set, or replication controller by name and creates an autoscaler that uses the given resource as a reference. An autoscaler can automatically increase or decrease number of pods deployed within the system as needed.
### Usage
`$ kubectl autoscale (-f FILENAME | TYPE NAME | TYPE/NAME) [--min=MINPODS] --max=MAXPODS [--cpu-percent=CPU]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| cpu-percent | | \-1 | The target average CPU utilization (represented as a percent of requested CPU) over all the pods. If it's not specified or negative, a default autoscaling policy will be used. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-autoscale | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to autoscale. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| max | | \-1 | The upper limit for the number of pods that can be set by the autoscaler. Required. |
| min | | \-1 | The lower limit for the number of pods that can be set by the autoscaler. If it's not specified or negative, the server will apply a default value. |
| name | | | The name for the newly created object. If not specified, the name of the input resource will be used. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
debug
=====
> Create an interactive debugging session in pod mypod and immediately attach to it. # (requires the EphemeralContainers feature to be enabled in the cluster)
kubectl debug mypod -it --image=busybox
> Create a debug container named debugger using a custom automated debugging image. # (requires the EphemeralContainers feature to be enabled in the cluster)
kubectl debug --image=myproj/debug-tools -c debugger mypod
> Create a copy of mypod adding a debug container and attach to it
kubectl debug mypod -it --image=busybox --copy-to=my-debugger
> Create a copy of mypod changing the command of mycontainer
kubectl debug mypod -it --copy-to=my-debugger --container=mycontainer -- sh
> Create a copy of mypod changing all container images to busybox
kubectl debug mypod --copy-to=my-debugger --set-image=*=busybox
> Create a copy of mypod adding a debug container and changing container images
kubectl debug mypod -it --copy-to=my-debugger --image=debian --set-image=app=app:debug,sidecar=sidecar:debug
> Create an interactive debugging session on a node and immediately attach to it. # The container will run in the host namespaces and the host's filesystem will be mounted at /host
kubectl debug node/mynode -it --image=busybox
Debug cluster resources using interactive debugging containers.
'debug' provides automation for common debugging tasks for cluster objects identified by resource and name. Pods will be used by default if no resource is specified.
The action taken by 'debug' varies depending on what resource is specified. Supported actions include:
_Workload: Create a copy of an existing pod with certain attributes changed, for example changing the image tag to a new version.
_Workload: Add an ephemeral container to an already running pod, for example to add debugging utilities without restarting the pod.
\* Node: Create a new pod that runs in the node's host namespaces and can access the node's filesystem.
### Usage
`$ kubectl debug (POD | TYPE[[.VERSION].GROUP]/NAME) [ -- COMMAND [args...] ]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| arguments-only | | false | If specified, everything after -- will be passed to the new container as Args instead of Command. |
| attach | | false | If true, wait for the container to start running, and then attach as if 'kubectl attach ...' were called. Default false, unless '-i/--stdin' is set, in which case the default is true. |
| container | c | | Container name to use for debug container. |
| copy-to | | | Create a copy of the target Pod with this name. |
| env | | \[\] | Environment variables to set in the container. |
| image | | | Container image to use for debug container. |
| image-pull-policy | | | The image pull policy for the container. If left empty, this value will not be specified by the client and defaulted by the server. |
| profile | | legacy | Debugging profile. |
| quiet | q | false | If true, suppress informational messages. |
| replace | | false | When used with '--copy-to', delete the original Pod. |
| same-node | | false | When used with '--copy-to', schedule the copy of target Pod on the same node. |
| set-image | | \[\] | When used with '--copy-to', a list of name=image pairs for changing container images, similar to how 'kubectl set image' works. |
| share-processes | | true | When used with '--copy-to', enable process namespace sharing in the copy. |
| stdin | i | false | Keep stdin open on the container(s) in the pod, even if nothing is attached. |
| target | | | When using an ephemeral container, target processes in this container name. |
| tty | t | false | Allocate a TTY for the debugging container. |
* * *
diff
====
> Diff resources included in pod.json
kubectl diff -f pod.json
> Diff file read from stdin
cat service.yaml | kubectl diff -f -
Diff configurations specified by file name or stdin between the current online configuration, and the configuration as it would be if applied.
The output is always YAML.
KUBECTL\_EXTERNAL\_DIFF environment variable can be used to select your own diff command. Users can use external commands with params too, example: KUBECTL\_EXTERNAL\_DIFF="colordiff -N -u"
By default, the "diff" command available in your path will be run with the "-u" (unified diff) and "-N" (treat absent files as empty) options.
Exit status: 0 No differences were found. 1 Differences were found. >1 Kubectl or diff failed with an error.
Note: KUBECTL\_EXTERNAL\_DIFF, if used, is expected to follow that convention.
### Usage
`$ kubectl diff -f FILENAME`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| field-manager | | kubectl-client-side-apply | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files contains the configuration to diff |
| force-conflicts | | false | If true, server-side apply will force the changes against conflicts. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| prune | | false | Include resources that would be deleted by pruning. Can be used with -l and default shows all resources would be pruned |
| prune-allowlist | | \[\] | Overwrite the default whitelist with for --prune |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| server-side | | false | If true, apply runs in the server instead of the client. |
| show-managed-fields | | false | If true, include managed fields in the diff. |
* * *
edit
====
> Edit the service named 'registry'
kubectl edit svc/registry
> Use an alternative editor
KUBE_EDITOR="nano" kubectl edit svc/registry
> Edit the job 'myjob' in JSON using the v1 API format
kubectl edit job.v1.batch/myjob -o json
> Edit the deployment 'mydeployment' in YAML and save the modified config in its annotation
kubectl edit deployment/mydeployment -o yaml --save-config
> Edit the deployment/mydeployment's status subresource
kubectl edit deployment mydeployment --subresource='status'
Edit a resource from the default editor.
The edit command allows you to directly edit any API resource you can retrieve via the command-line tools. It will open the editor defined by your KUBE\_EDITOR, or EDITOR environment variables, or fall back to 'vi' for Linux or 'notepad' for Windows. You can edit multiple objects, although changes are applied one at a time. The command accepts file names as well as command-line arguments, although the files you point to must be previously saved versions of resources.
Editing is done with the API version used to fetch the resource. To edit using a specific API version, fully-qualify the resource, version, and group.
The default format is YAML. To edit in JSON, specify "-o json".
The flag --windows-line-endings can be used to force Windows line endings, otherwise the default for your operating system will be used.
In the event an error occurs while updating, a temporary file will be created on disk that contains your unapplied changes. The most common error when updating a resource is another editor changing the resource on the server. When this occurs, you will have to apply your changes to the newer version of the resource, or update your temporary saved copy to include the latest resource version.
### Usage
`$ kubectl edit (RESOURCE/NAME | -f FILENAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| field-manager | | kubectl-edit | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files to use to edit the resource |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| output-patch | | false | Output the patch if the resource is edited. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| subresource | | | If specified, edit will operate on the subresource of the requested object. Must be one of \[status\]. This flag is alpha and may change in the future. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| windows-line-endings | | false | Defaults to the line ending native to your platform. |
* * *
kustomize
=========
> Build the current working directory
kubectl kustomize
> Build some shared configuration directory
kubectl kustomize /home/config/production
> Build from github
kubectl kustomize https://github.com/kubernetes-sigs/kustomize.git/examples/helloWorld?ref=v1.0.6
Build a set of KRM resources using a 'kustomization.yaml' file. The DIR argument must be a path to a directory containing 'kustomization.yaml', or a git repository URL with a path suffix specifying same with respect to the repository root. If DIR is omitted, '.' is assumed.
### Usage
`$ kubectl kustomize DIR`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| as-current-user | | false | use the uid and gid of the command executor to run the function in the container |
| enable-alpha-plugins | | false | enable kustomize plugins |
| enable-helm | | false | Enable use of the Helm chart inflator generator. |
| enable-managedby-label | | false | enable adding app.kubernetes.io/managed-by |
| env | e | \[\] | a list of environment variables to be used by functions |
| helm-command | | helm | helm command (path to executable) |
| load-restrictor | | LoadRestrictionsRootOnly | if set to 'LoadRestrictionsNone', local kustomizations may load files from outside their root. This does, however, break the relocatability of the kustomization. |
| mount | | \[\] | a list of storage options read from the filesystem |
| network | | false | enable network access for functions that declare it |
| network-name | | bridge | the docker network to run the container in |
| output | o | | If specified, write output to this path. |
| reorder | | legacy | Reorder the resources just before output. Use 'legacy' to apply a legacy reordering (Namespaces first, Webhooks last, etc). Use 'none' to suppress a final reordering. |
* * *
label
=====
> Update pod 'foo' with the label 'unhealthy' and the value 'true'
kubectl label pods foo unhealthy=true
> Update pod 'foo' with the label 'status' and the value 'unhealthy', overwriting any existing value
kubectl label --overwrite pods foo status=unhealthy
> Update all pods in the namespace
kubectl label pods --all status=unhealthy
> Update a pod identified by the type and name in "pod.json"
kubectl label -f pod.json status=unhealthy
> Update pod 'foo' only if the resource is unchanged from version 1
kubectl label pods foo status=unhealthy --resource-version=1
> Update pod 'foo' by removing a label named 'bar' if it exists # Does not require the --overwrite flag
kubectl label pods foo bar-
Update the labels on a resource.
_A label key and value must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to 63 characters each.
_Optionally, the key can begin with a DNS subdomain prefix and a single '/', like example.com/my-app.
_If --overwrite is true, then existing labels can be overwritten, otherwise attempting to overwrite a label will result in an error.
_If --resource-version is specified, then updates will use this resource version, otherwise the existing resource-version will be used.
### Usage
`$ kubectl label [--overwrite] (-f FILENAME | TYPE NAME) KEY_1=VAL_1 ... KEY_N=VAL_N [--resource-version=version]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources, in the namespace of the specified resource types |
| all-namespaces | A | false | If true, check the specified action in all namespaces. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-label | Name of the manager used to track field ownership. |
| field-selector | | | Selector (field query) to filter on, supports '=', '==', and '!='.(e.g. --field-selector key1=value1,key2=value2). The server only supports a limited number of field queries per type. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to update the labels |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| list | | false | If true, display the labels for a given resource. |
| local | | false | If true, label will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| overwrite | | false | If true, allow labels to be overwritten, otherwise reject label updates that overwrite existing labels. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| resource-version | | | If non-empty, the labels update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
patch
=====
> Partially update a node using a strategic merge patch, specifying the patch as JSON
kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}'
> Partially update a node using a strategic merge patch, specifying the patch as YAML
kubectl patch node k8s-node-1 -p $'spec:\n unschedulable: true'
> Partially update a node identified by the type and name specified in "node.json" using strategic merge patch
kubectl patch -f node.json -p '{"spec":{"unschedulable":true}}'
> Update a container's image; spec.containers\[\*\].name is required because it's a merge key
kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'
> Update a container's image using a JSON patch with positional arrays
kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'
> Update a deployment's replicas through the scale subresource using a merge patch.
kubectl patch deployment nginx-deployment --subresource='scale' --type='merge' -p '{"spec":{"replicas":2}}'
Update fields of a resource using strategic merge patch, a JSON merge patch, or a JSON patch.
JSON and YAML formats are accepted.
Note: Strategic merge patch is not supported for custom resources.
### Usage
`$ kubectl patch (-f FILENAME | TYPE NAME) [-p PATCH|--patch-file FILE]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-patch | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to update |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| local | | false | If true, patch will operate on the content of the file, not the server-side resource. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| patch | p | | The patch to be applied to the resource JSON file. |
| patch-file | | | A file containing a patch to be applied to the resource. |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| subresource | | | If specified, patch will operate on the subresource of the requested object. Must be one of \[status scale\]. This flag is alpha and may change in the future. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| type | | strategic | The type of patch being provided; one of \[json merge strategic\] |
* * *
replace
=======
> Replace a pod using the data in pod.json
kubectl replace -f ./pod.json
> Replace a pod based on the JSON passed into stdin
cat pod.json | kubectl replace -f -
> Update a single-container pod's image version (tag) to v4
kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/\1:v4/' | kubectl replace -f -
> Force replace, delete and then re-create the resource
kubectl replace --force -f ./pod.json
Replace a resource by file name or stdin.
JSON and YAML formats are accepted. If replacing an existing resource, the complete resource spec must be provided. This can be obtained by
$ kubectl get TYPE NAME -o yaml
### Usage
`$ kubectl replace -f FILENAME`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| cascade | | background | Must be "background", "orphan", or "foreground". Selects the deletion cascading strategy for the dependents (e.g. Pods created by a ReplicationController). Defaults to background. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-replace | Name of the manager used to track field ownership. |
| filename | f | \[\] | The files that contain the configurations to replace. |
| force | | false | If true, immediately remove resources from API and bypass graceful deletion. Note that immediate deletion of some resources may result in inconsistency or data loss and requires confirmation. |
| grace-period | | \-1 | Period of time in seconds given to the resource to terminate gracefully. Ignored if negative. Set to 1 for immediate shutdown. Can only be set to 0 when --force is true (force deletion). |
| kustomize | k | | Process a kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| raw | | | Raw URI to PUT to the server. Uses the transport specified by the kubeconfig file. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| save-config | | false | If true, the configuration of current object will be saved in its annotation. Otherwise, the annotation will be unchanged. This flag is useful when you want to perform kubectl apply on this object in the future. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| subresource | | | If specified, replace will operate on the subresource of the requested object. Must be one of \[status scale\]. This flag is alpha and may change in the future. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| timeout | | 0s | The length of time to wait before giving up on a delete, zero means determine a timeout from the size of the object |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
| wait | | false | If true, wait for resources to be gone before returning. This waits for finalizers. |
* * *
rollout
=======
> Rollback to the previous deployment
kubectl rollout undo deployment/abc
> Check the rollout status of a daemonset
kubectl rollout status daemonset/foo
> Restart a deployment
kubectl rollout restart deployment/abc
> Restart deployments with the app=nginx label
kubectl rollout restart deployment --selector=app=nginx
Manage the rollout of one or many resources.
Valid resource types include:
_deployments
_daemonsets
\* statefulsets
### Usage
`$ kubectl rollout SUBCOMMAND`
* * *
_history_
---------
> View the rollout history of a deployment
kubectl rollout history deployment/abc
> View the details of daemonset revision 3
kubectl rollout history daemonset/abc --revision=3
View previous rollout revisions and configurations.
### Usage
`$ kubectl rollout history (TYPE NAME | TYPE/NAME) [flags]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| revision | | 0 | See the details, including podTemplate of the revision specified |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_pause_
-------
> Mark the nginx deployment as paused # Any current state of the deployment will continue its function; new updates # to the deployment will not have an effect as long as the deployment is paused
kubectl rollout pause deployment/nginx
Mark the provided resource as paused.
Paused resources will not be reconciled by a controller. Use "kubectl rollout resume" to resume a paused resource. Currently only deployments support being paused.
### Usage
`$ kubectl rollout pause RESOURCE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| field-manager | | kubectl-rollout | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_restart_
---------
> Restart a deployment
kubectl rollout restart deployment/nginx
> Restart a daemon set
kubectl rollout restart daemonset/abc
> Restart deployments with the app=nginx label
kubectl rollout restart deployment --selector=app=nginx
Restart a resource.
Resource rollout will be restarted.
### Usage
`$ kubectl rollout restart RESOURCE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| field-manager | | kubectl-rollout | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_resume_
--------
> Resume an already paused deployment
kubectl rollout resume deployment/nginx
Resume a paused resource.
Paused resources will not be reconciled by a controller. By resuming a resource, we allow it to be reconciled again. Currently only deployments support being resumed.
### Usage
`$ kubectl rollout resume RESOURCE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| field-manager | | kubectl-rollout | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_status_
--------
> Watch the rollout status of a deployment
kubectl rollout status deployment/nginx
Show the status of the rollout.
By default 'rollout status' will watch the status of the latest rollout until it's done. If you don't want to wait for the rollout to finish then you can use --watch=false. Note that if a new rollout starts in-between, then 'rollout status' will continue watching the latest revision. If you want to pin to a specific revision and abort if it is rolled over by another revision, use --revision=N where N is the revision you need to watch for.
### Usage
`$ kubectl rollout status (TYPE NAME | TYPE/NAME) [flags]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| revision | | 0 | Pin to a specific revision for showing its status. Defaults to 0 (last revision). |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| timeout | | 0s | The length of time to wait before ending watch, zero means never. Any other values should contain a corresponding time unit (e.g. 1s, 2m, 3h). |
| watch | w | true | Watch the status of the rollout until it's done. |
* * *
_undo_
------
> Roll back to the previous deployment
kubectl rollout undo deployment/abc
> Roll back to daemonset revision 3
kubectl rollout undo daemonset/abc --to-revision=3
> Roll back to the previous deployment with dry-run
kubectl rollout undo --dry-run=server deployment/abc
Roll back to a previous rollout.
### Usage
`$ kubectl rollout undo (TYPE NAME | TYPE/NAME) [flags]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| to-revision | | 0 | The revision to rollback to. Default to 0 (last revision). |
* * *
scale
=====
> Scale a replica set named 'foo' to 3
kubectl scale --replicas=3 rs/foo
> Scale a resource identified by type and name specified in "foo.yaml" to 3
kubectl scale --replicas=3 -f foo.yaml
> If the deployment named mysql's current size is 2, scale mysql to 3
kubectl scale --current-replicas=2 --replicas=3 deployment/mysql
> Scale multiple replication controllers
kubectl scale --replicas=5 rc/foo rc/bar rc/baz
> Scale stateful set named 'web' to 3
kubectl scale --replicas=3 statefulset/web
Set a new size for a deployment, replica set, replication controller, or stateful set.
Scale also allows users to specify one or more preconditions for the scale action.
If --current-replicas or --resource-version is specified, it is validated before the scale is attempted, and it is guaranteed that the precondition holds true when the scale is sent to the server.
### Usage
`$ kubectl scale [--resource-version=version] [--current-replicas=count] --replicas=COUNT (-f FILENAME | TYPE NAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| current-replicas | | \-1 | Precondition for current size. Requires that the current size of the resource match this value in order to scale. -1 (default) for no condition. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to set a new size |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| replicas | | 0 | The new desired number of replicas. Required. |
| resource-version | | | Precondition for resource version. Requires that the current resource version match this value in order to scale. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| timeout | | 0s | The length of time to wait before giving up on a scale operation, zero means don't wait. Any other values should contain a corresponding time unit (e.g. 1s, 2m, 3h). |
* * *
set
===
Configure application resources.
These commands help you make changes to existing application resources.
### Usage
`$ kubectl set SUBCOMMAND`
* * *
_env_
-----
> Update deployment 'registry' with a new environment variable
kubectl set env deployment/registry STORAGE_DIR=/local
> List the environment variables defined on a deployments 'sample-build'
kubectl set env deployment/sample-build --list
> List the environment variables defined on all pods
kubectl set env pods --all --list
> Output modified deployment in YAML, and does not alter the object on the server
kubectl set env deployment/sample-build STORAGE_DIR=/data -o yaml
> Update all containers in all replication controllers in the project to have ENV=prod
kubectl set env rc --all ENV=prod
> Import environment from a secret
kubectl set env --from=secret/mysecret deployment/myapp
> Import environment from a config map with a prefix
kubectl set env --from=configmap/myconfigmap --prefix=MYSQL_ deployment/myapp
> Import specific keys from a config map
kubectl set env --keys=my-example-key --from=configmap/myconfigmap deployment/myapp
> Remove the environment variable ENV from container 'c1' in all deployment configs
kubectl set env deployments --all --containers="c1" ENV-
> Remove the environment variable ENV from a deployment definition on disk and # update the deployment config on the server
kubectl set env -f deploy.json ENV-
> Set some of the local shell environment into a deployment config on the server
env | grep RAILS_ | kubectl set env -e - deployment/registry
Update environment variables on a pod template.
List environment variable definitions in one or more pods, pod templates. Add, update, or remove container environment variable definitions in one or more pod templates (within replication controllers or deployment configurations). View or modify the environment variable definitions on all containers in the specified pods or pod templates, or just those that match a wildcard.
If "--env -" is passed, environment variables can be read from STDIN using the standard env syntax.
Possible resources include (case insensitive):
pod (po), replicationcontroller (rc), deployment (deploy), daemonset (ds), statefulset (sts), cronjob (cj), replicaset (rs)
### Usage
`$ kubectl set env RESOURCE/NAME KEY_1=VAL_1 ... KEY_N=VAL_N`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | If true, select all resources in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| containers | c | \* | The names of containers in the selected pod templates to change - may use wildcards |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| env | e | \[\] | Specify a key-value pair for an environment variable to set into each container. |
| field-manager | | kubectl-set | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files the resource to update the env |
| from | | | The name of a resource from which to inject environment variables |
| keys | | \[\] | Comma-separated list of keys to import from specified resource |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| list | | false | If true, display the environment and any changes in the standard format. this flag will removed when we have kubectl view env. |
| local | | false | If true, set env will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| overwrite | | true | If true, allow environment to be overwritten, otherwise reject updates that overwrite existing environment. |
| prefix | | | Prefix to append to variable names |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| resolve | | false | If true, show secret or configmap references when listing variables |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_image_
-------
> Set a deployment's nginx container image to 'nginx:1.9.1', and its busybox container image to 'busybox'
kubectl set image deployment/nginx busybox=busybox nginx=nginx:1.9.1
> Update all deployments' and rc's nginx container's image to 'nginx:1.9.1'
kubectl set image deployments,rc nginx=nginx:1.9.1 --all
> Update image of all containers of daemonset abc to 'nginx:1.9.1'
kubectl set image daemonset abc *=nginx:1.9.1
> Print result (in yaml format) of updating nginx container image from local file, without hitting the server
kubectl set image -f path/to/file.yaml nginx=nginx:1.9.1 --local -o yaml
Update existing container image(s) of resources.
Possible resources include (case insensitive):
pod (po), replicationcontroller (rc), deployment (deploy), daemonset (ds), statefulset (sts), cronjob (cj), replicaset (rs)
### Usage
`$ kubectl set image (-f FILENAME | TYPE NAME) CONTAINER_NAME_1=CONTAINER_IMAGE_1 ... CONTAINER_NAME_N=CONTAINER_IMAGE_N`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources, in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-set | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| local | | false | If true, set image will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_resources_
-----------
> Set a deployments nginx container cpu limits to "200m" and memory to "512Mi"
kubectl set resources deployment nginx -c=nginx --limits=cpu=200m,memory=512Mi
> Set the resource request and limits for all containers in nginx
kubectl set resources deployment nginx --limits=cpu=200m,memory=512Mi --requests=cpu=100m,memory=256Mi
> Remove the resource requests for resources on containers in nginx
kubectl set resources deployment nginx --limits=cpu=0,memory=0 --requests=cpu=0,memory=0
> Print the result (in yaml format) of updating nginx container limits from a local, without hitting the server
kubectl set resources -f path/to/file.yaml --limits=cpu=200m,memory=512Mi --local -o yaml
Specify compute resource requirements (CPU, memory) for any resource that defines a pod template. If a pod is successfully scheduled, it is guaranteed the amount of resource requested, but may burst up to its specified limits.
For each compute resource, if a limit is specified and a request is omitted, the request will default to the limit.
Possible resources include (case insensitive): Use "kubectl api-resources" for a complete list of supported resources..
### Usage
`$ kubectl set resources (-f FILENAME | TYPE NAME) ([--limits=LIMITS & --requests=REQUESTS]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources, in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| containers | c | \* | The names of containers in the selected pod templates to change, all containers are selected by default - may use wildcards |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-set | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| limits | | | The resource requirement requests for this container. For example, 'cpu=100m,memory=256Mi'. Note that server side components may assign requests depending on the server configuration, such as limit ranges. |
| local | | false | If true, set resources will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| requests | | | The resource requirement requests for this container. For example, 'cpu=100m,memory=256Mi'. Note that server side components may assign requests depending on the server configuration, such as limit ranges. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_selector_
----------
> Set the labels and selector before creating a deployment/service pair
kubectl create service clusterip my-svc --clusterip="None" -o yaml --dry-run=client | kubectl set selector --local -f - 'environment=qa' -o yaml | kubectl create -f -
kubectl create deployment my-dep -o yaml --dry-run=client | kubectl label --local -f - environment=qa -o yaml | kubectl create -f -
Set the selector on a resource. Note that the new selector will overwrite the old selector if the resource had one prior to the invocation of 'set selector'.
A selector must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to 63 characters. If --resource-version is specified, then updates will use this resource version, otherwise the existing resource-version will be used. Note: currently selectors can only be set on Service objects.
### Usage
`$ kubectl set selector (-f FILENAME | TYPE NAME) EXPRESSIONS [--resource-version=version]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-set | Name of the manager used to track field ownership. |
| filename | f | \[\] | identifying the resource. |
| local | | false | If true, annotation will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | true | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| resource-version | | | If non-empty, the selectors update will only succeed if this is the current resource-version for the object. Only valid when specifying a single resource. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_serviceaccount_
----------------
> Set deployment nginx-deployment's service account to serviceaccount1
kubectl set serviceaccount deployment nginx-deployment serviceaccount1
> Print the result (in YAML format) of updated nginx deployment with the service account from local file, without hitting the API server
kubectl set sa -f nginx-deployment.yaml serviceaccount1 --local --dry-run=client -o yaml
Update the service account of pod template resources.
Possible resources (case insensitive) can be:
replicationcontroller (rc), deployment (deploy), daemonset (ds), job, replicaset (rs), statefulset
### Usage
`$ kubectl set serviceaccount (-f FILENAME | TYPE NAME) SERVICE_ACCOUNT`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources, in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-set | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to get from a server. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| local | | false | If true, set serviceaccount will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| record | | false | Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_subject_
---------
> Update a cluster role binding for serviceaccount1
kubectl set subject clusterrolebinding admin --serviceaccount=namespace:serviceaccount1
> Update a role binding for user1, user2, and group1
kubectl set subject rolebinding admin --user=user1 --user=user2 --group=group1
> Print the result (in YAML format) of updating rolebinding subjects from a local, without hitting the server
kubectl create rolebinding admin --role=admin --user=admin -o yaml --dry-run=client | kubectl set subject --local -f - --user=foo -o yaml
Update the user, group, or service account in a role binding or cluster role binding.
### Usage
`$ kubectl set subject (-f FILENAME | TYPE NAME) [--user=username] [--group=groupname] [--serviceaccount=namespace:serviceaccountname] [--dry-run=server|client|none]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources, in the namespace of the specified resource types |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-set | Name of the manager used to track field ownership. |
| filename | f | \[\] | Filename, directory, or URL to files the resource to update the subjects |
| group | | \[\] | Groups to bind to the role |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| local | | false | If true, set subject will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| serviceaccount | | \[\] | Service accounts to bind to the role |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| user | | \[\] | Usernames to bind to the role |
* * *
wait
====
> Wait for the pod "busybox1" to contain the status condition of type "Ready"
kubectl wait --for=condition=Ready pod/busybox1
> The default value of status condition is true; you can wait for other targets after an equal delimiter (compared after Unicode simple case folding, which is a more general form of case-insensitivity):
kubectl wait --for=condition=Ready=false pod/busybox1
> Wait for the pod "busybox1" to contain the status phase to be "Running".
kubectl wait --for=jsonpath='{.status.phase}'=Running pod/busybox1
> Wait for the pod "busybox1" to be deleted, with a timeout of 60s, after having issued the "delete" command
kubectl delete pod/busybox1
kubectl wait --for=delete pod/busybox1 --timeout=60s
Experimental: Wait for a specific condition on one or many resources.
The command takes multiple resources and waits until the specified condition is seen in the Status field of every given resource.
Alternatively, the command can wait for the given set of resources to be deleted by providing the "delete" keyword as the value to the --for flag.
A successful message will be printed to stdout indicating when the specified condition has been met. You can use -o option to change to output destination.
### Usage
`$ kubectl wait ([-f FILENAME] | resource.group/resource.name | resource.group [(-l label | --all)]) [--for=delete|--for condition=available|--for=jsonpath='{}'=value]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all resources in the namespace of the specified resource types |
| all-namespaces | A | false | If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| field-selector | | | Selector (field query) to filter on, supports '=', '==', and '!='.(e.g. --field-selector key1=value1,key2=value2). The server only supports a limited number of field queries per type. |
| filename | f | \[\] | identifying the resource. |
| for | | | The condition to wait on: \[delete\|condition=condition-name\[\=condition-value\]\|jsonpath='{JSONPath expression}'=JSONPath Condition\]. The default condition-value is true. Condition values are compared after Unicode simple case folding, which is a more general form of case-insensitivity. |
| local | | false | If true, annotation will NOT contact api-server but run locally. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | true | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2) |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| timeout | | 30s | The length of time to wait before giving up. Zero means check once and don't wait, negative means wait for a week. |
**WORKING WITH APPS**
=====================
This section contains commands for inspecting and debugging your applications.
* `logs` will print the logs from the specified pod + container.
* `exec` can be used to get an interactive shell on a pod + container.
* `describe` will print debug information about the given resource.
* * *
attach
======
> Get output from running pod mypod; use the 'kubectl.kubernetes.io/default-container' annotation # for selecting the container to be attached or the first container in the pod will be chosen
kubectl attach mypod
> Get output from ruby-container from pod mypod
kubectl attach mypod -c ruby-container
> Switch to raw terminal mode; sends stdin to 'bash' in ruby-container from pod mypod # and sends stdout/stderr from 'bash' back to the client
kubectl attach mypod -c ruby-container -i -t
> Get output from the first pod of a replica set named nginx
kubectl attach rs/nginx
Attach to a process that is already running inside an existing container.
### Usage
`$ kubectl attach (POD | TYPE/NAME) -c CONTAINER`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| container | c | | Container name. If omitted, use the kubectl.kubernetes.io/default-container annotation for selecting the container to be attached or the first container in the pod will be chosen |
| pod-running-timeout | | 1m0s | The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running |
| quiet | q | false | Only print output from the remote session |
| stdin | i | false | Pass stdin to the container |
| tty | t | false | Stdin is a TTY |
* * *
auth
====
Inspect authorization
### Usage
`$ kubectl auth`
* * *
_can-i_
-------
> Check to see if I can create pods in any namespace
kubectl auth can-i create pods --all-namespaces
> Check to see if I can list deployments in my current namespace
kubectl auth can-i list deployments.apps
> Check to see if I can do everything in my current namespace ("\*" means all)
kubectl auth can-i '*' '*'
> Check to see if I can get the job named "bar" in namespace "foo"
kubectl auth can-i list jobs.batch/bar -n foo
> Check to see if I can read pod logs
kubectl auth can-i get pods --subresource=log
> Check to see if I can access the URL /logs/
kubectl auth can-i get /logs/
> List all allowed actions in namespace "foo"
kubectl auth can-i --list --namespace=foo
Check whether an action is allowed.
VERB is a logical Kubernetes API verb like 'get', 'list', 'watch', 'delete', etc. TYPE is a Kubernetes resource. Shortcuts and groups will be resolved. NONRESOURCEURL is a partial URL that starts with "/". NAME is the name of a particular Kubernetes resource. This command pairs nicely with impersonation. See --as global flag.
### Usage
`$ kubectl auth can-i VERB [TYPE | TYPE/NAME | NONRESOURCEURL]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-namespaces | A | false | If true, check the specified action in all namespaces. |
| list | | false | If true, prints all allowed actions. |
| no-headers | | false | If true, prints allowed actions without headers |
| quiet | q | false | If true, suppress output and just return the exit code. |
| subresource | | | SubResource such as pod/log or deployment/scale |
* * *
_reconcile_
-----------
> Reconcile RBAC resources from a file
kubectl auth reconcile -f my-rbac-rules.yaml
Reconciles rules for RBAC role, role binding, cluster role, and cluster role binding objects.
Missing objects are created, and the containing namespace is created for namespaced objects, if required.
Existing roles are updated to include the permissions in the input objects, and remove extra permissions if --remove-extra-permissions is specified.
Existing bindings are updated to include the subjects in the input objects, and remove extra subjects if --remove-extra-subjects is specified.
This is preferred to 'apply' for RBAC resources so that semantically-aware merging of rules and subjects is done.
### Usage
`$ kubectl auth reconcile -f FILENAME`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to reconcile. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| remove-extra-permissions | | false | If true, removes extra permissions added to roles |
| remove-extra-subjects | | false | If true, removes extra subjects added to rolebindings |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
cp
==
> !!!Important Note!!! # Requires that the 'tar' binary is present in your container # image. If 'tar' is not present, 'kubectl cp' will fail. # # For advanced use cases, such as symlinks, wildcard expansion or # file mode preservation, consider using 'kubectl exec'. # Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace
tar cf - /tmp/foo | kubectl exec -i -n -- tar xf - -C /tmp/bar
> Copy /tmp/foo from a remote pod to /tmp/bar locally
kubectl exec -n -- tar cf - /tmp/foo | tar xf - -C /tmp/bar
> Copy /tmp/foo\_dir local directory to /tmp/bar\_dir in a remote pod in the default namespace
kubectl cp /tmp/foo_dir :/tmp/bar_dir
> Copy /tmp/foo local file to /tmp/bar in a remote pod in a specific container
kubectl cp /tmp/foo :/tmp/bar -c
> Copy /tmp/foo local file to /tmp/bar in a remote pod in namespace
kubectl cp /tmp/foo /:/tmp/bar
> Copy /tmp/foo from a remote pod to /tmp/bar locally
kubectl cp /:/tmp/foo /tmp/bar
Copy files and directories to and from containers.
### Usage
`$ kubectl cp `
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| container | c | | Container name. If omitted, use the kubectl.kubernetes.io/default-container annotation for selecting the container to be attached or the first container in the pod will be chosen |
| no-preserve | | false | The copied file/directory's ownership and permissions will not be preserved in the container |
| retries | | 0 | Set number of retries to complete a copy operation from a container. Specify 0 to disable or any negative value for infinite retrying. The default is 0 (no retry). |
* * *
describe
========
> Describe a node
kubectl describe nodes kubernetes-node-emt8.c.myproject.internal
> Describe a pod
kubectl describe pods/nginx
> Describe a pod identified by type and name in "pod.json"
kubectl describe -f pod.json
> Describe all pods
kubectl describe pods
> Describe pods by label name=myLabel
kubectl describe po -l name=myLabel
> Describe all pods managed by the 'frontend' replication controller # (rc-created pods get the name of the rc as a prefix in the pod name)
kubectl describe pods frontend
Show details of a specific resource or group of resources.
Print a detailed description of the selected resources, including related resources such as events or controllers. You may select a single object by name, all objects of that type, provide a name prefix, or label selector. For example:
$ kubectl describe TYPE NAME\_PREFIX
will first check for an exact match on TYPE and NAME\_PREFIX. If no such resource exists, it will output details for every resource that has a name prefixed with NAME\_PREFIX.
Use "kubectl api-resources" for a complete list of supported resources.
### Usage
`$ kubectl describe (-f FILENAME | TYPE [NAME_PREFIX | -l label] | TYPE/NAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-namespaces | A | false | If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace. |
| chunk-size | | 500 | Return large lists in chunks rather than all at once. Pass 0 to disable. This flag is beta and may change in the future. |
| filename | f | \[\] | Filename, directory, or URL to files containing the resource to describe |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-events | | true | If true, display events related to the described object. |
* * *
events
======
> List recent events in the default namespace.
kubectl events
> List recent events in all namespaces.
kubectl events --all-namespaces
> List recent events for the specified pod, then wait for more events and list them as they arrive.
kubectl events --for pod/web-pod-13je7 --watch
> List recent events in given format. Supported ones, apart from default, are json and yaml.
kubectl events -oyaml
> List recent only events in given event types
kubectl events --types=Warning,Normal
Display events
Prints a table of the most important information about events. You can request events for a namespace, for all namespace, or filtered to only those pertaining to a specified resource.
### Usage
`$ kubectl events [(-o|--output=)json|yaml|name|go-template|go-template-file|template|templatefile|jsonpath|jsonpath-as-json|jsonpath-file] [--for TYPE/NAME] [--watch] [--event=Normal,Warning]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-namespaces | A | false | If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| chunk-size | | 500 | Return large lists in chunks rather than all at once. Pass 0 to disable. This flag is beta and may change in the future. |
| for | | | Filter events to only those pertaining to the specified resource. |
| no-headers | | false | When using the default output format, don't print headers. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| types | | \[\] | Output only events of given types. |
| watch | w | false | After listing the requested events, watch for more events. |
* * *
exec
====
> Get output from running the 'date' command from pod mypod, using the first container by default
kubectl exec mypod -- date
> Get output from running the 'date' command in ruby-container from pod mypod
kubectl exec mypod -c ruby-container -- date
> Switch to raw terminal mode; sends stdin to 'bash' in ruby-container from pod mypod # and sends stdout/stderr from 'bash' back to the client
kubectl exec mypod -c ruby-container -i -t -- bash -il
> List contents of /usr from the first container of pod mypod and sort by modification time # If the command you want to execute in the pod has any flags in common (e.g. -i), # you must use two dashes (--) to separate your command's flags/arguments # Also note, do not surround your command and its flags/arguments with quotes # unless that is how you would execute it normally (i.e., do ls -t /usr, not "ls -t /usr")
kubectl exec mypod -i -t -- ls -t /usr
> Get output from running 'date' command from the first pod of the deployment mydeployment, using the first container by default
kubectl exec deploy/mydeployment -- date
> Get output from running 'date' command from the first pod of the service myservice, using the first container by default
kubectl exec svc/myservice -- date
Execute a command in a container.
### Usage
`$ kubectl exec (POD | TYPE/NAME) [-c CONTAINER] [flags] -- COMMAND [args...]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| container | c | | Container name. If omitted, use the kubectl.kubernetes.io/default-container annotation for selecting the container to be attached or the first container in the pod will be chosen |
| filename | f | \[\] | to use to exec into the resource |
| pod-running-timeout | | 1m0s | The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running |
| quiet | q | false | Only print output from the remote session |
| stdin | i | false | Pass stdin to the container |
| tty | t | false | Stdin is a TTY |
* * *
logs
====
> Return snapshot logs from pod nginx with only one container
kubectl logs nginx
> Return snapshot logs from pod nginx with multi containers
kubectl logs nginx --all-containers=true
> Return snapshot logs from all containers in pods defined by label app=nginx
kubectl logs -l app=nginx --all-containers=true
> Return snapshot of previous terminated ruby container logs from pod web-1
kubectl logs -p -c ruby web-1
> Begin streaming the logs of the ruby container in pod web-1
kubectl logs -f -c ruby web-1
> Begin streaming the logs from all containers in pods defined by label app=nginx
kubectl logs -f -l app=nginx --all-containers=true
> Display only the most recent 20 lines of output in pod nginx
kubectl logs --tail=20 nginx
> Show all logs from pod nginx written in the last hour
kubectl logs --since=1h nginx
> Show logs from a kubelet with an expired serving certificate
kubectl logs --insecure-skip-tls-verify-backend nginx
> Return snapshot logs from first container of a job named hello
kubectl logs job/hello
> Return snapshot logs from container nginx-1 of a deployment named nginx
kubectl logs deployment/nginx -c nginx-1
Print the logs for a container in a pod or specified resource. If the pod has only one container, the container name is optional.
### Usage
`$ kubectl logs [-f] [-p] (POD | TYPE/NAME) [-c CONTAINER]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-containers | | false | Get all containers' logs in the pod(s). |
| container | c | | Print the logs of this container |
| follow | f | false | Specify if the logs should be streamed. |
| ignore-errors | | false | If watching / following pod logs, allow for any errors that occur to be non-fatal |
| insecure-skip-tls-verify-backend | | false | Skip verifying the identity of the kubelet that logs are requested from. In theory, an attacker could provide invalid log content back. You might want to use this if your kubelet serving certificates have expired. |
| limit-bytes | | 0 | Maximum bytes of logs to return. Defaults to no limit. |
| max-log-requests | | 5 | Specify maximum number of concurrent logs to follow when using by a selector. Defaults to 5. |
| pod-running-timeout | | 20s | The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running |
| prefix | | false | Prefix each log line with the log source (pod name and container name) |
| previous | p | false | If true, print the logs for the previous instance of the container in a pod if it exists. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| since | | 0s | Only return logs newer than a relative duration like 5s, 2m, or 3h. Defaults to all logs. Only one of since-time / since may be used. |
| since-time | | | Only return logs after a specific date (RFC3339). Defaults to all logs. Only one of since-time / since may be used. |
| tail | | \-1 | Lines of recent log file to display. Defaults to -1 with no selector, showing all log lines otherwise 10, if a selector is provided. |
| timestamps | | false | Include timestamps on each line in the log output |
* * *
port-forward
============
> Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
kubectl port-forward pod/mypod 5000 6000
> Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in a pod selected by the deployment
kubectl port-forward deployment/mydeployment 5000 6000
> Listen on port 8443 locally, forwarding to the targetPort of the service's port named "https" in a pod selected by the service
kubectl port-forward service/myservice 8443:https
> Listen on port 8888 locally, forwarding to 5000 in the pod
kubectl port-forward pod/mypod 8888:5000
> Listen on port 8888 on all addresses, forwarding to 5000 in the pod
kubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000
> Listen on port 8888 on localhost and selected IP, forwarding to 5000 in the pod
kubectl port-forward --address localhost,10.19.21.23 pod/mypod 8888:5000
> Listen on a random port locally, forwarding to 5000 in the pod
kubectl port-forward pod/mypod :5000
Forward one or more local ports to a pod.
Use resource type/name such as deployment/mydeployment to select a pod. Resource type defaults to 'pod' if omitted.
If there are multiple pods matching the criteria, a pod will be selected automatically. The forwarding session ends when the selected pod terminates, and a rerun of the command is needed to resume forwarding.
### Usage
`$ kubectl port-forward TYPE/NAME [options] [LOCAL_PORT:]REMOTE_PORT [...[LOCAL_PORT_N:]REMOTE_PORT_N]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| address | | \[localhost\] | Addresses to listen on (comma separated). Only accepts IP addresses or localhost as a value. When localhost is supplied, kubectl will try to bind on both 127.0.0.1 and ::1 and will fail if neither of these addresses are available to bind. |
| pod-running-timeout | | 1m0s | The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running |
* * *
proxy
=====
> To proxy all of the Kubernetes API and nothing else
kubectl proxy --api-prefix=/
> To proxy only part of the Kubernetes API and also some static files # You can get pods info with 'curl localhost:8001/api/v1/pods'
kubectl proxy --www=/my/files --www-prefix=/static/ --api-prefix=/api/
> To proxy the entire Kubernetes API at a different root # You can get pods info with 'curl localhost:8001/custom/api/v1/pods'
kubectl proxy --api-prefix=/custom/
> Run a proxy to the Kubernetes API server on port 8011, serving static content from ./local/www/
kubectl proxy --port=8011 --www=./local/www/
> Run a proxy to the Kubernetes API server on an arbitrary local port # The chosen port for the server will be output to stdout
kubectl proxy --port=0
> Run a proxy to the Kubernetes API server, changing the API prefix to k8s-api # This makes e.g. the pods API available at localhost:8001/k8s-api/v1/pods/
kubectl proxy --api-prefix=/k8s-api
Creates a proxy server or application-level gateway between localhost and the Kubernetes API server. It also allows serving static content over specified HTTP path. All incoming data enters through one port and gets forwarded to the remote Kubernetes API server port, except for the path matching the static content path.
### Usage
`$ kubectl proxy [--port=PORT] [--www=static-dir] [--www-prefix=prefix] [--api-prefix=prefix]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| accept-hosts | | ^localhost$,^127.0.0.1$,^\[::1\]$ | Regular expression for hosts that the proxy should accept. |
| accept-paths | | ^.\* | Regular expression for paths that the proxy should accept. |
| address | | 127.0.0.1 | The IP address on which to serve on. |
| api-prefix | | / | Prefix to serve the proxied API under. |
| append-server-path | | false | If true, enables automatic path appending of the kube context server path to each request. |
| disable-filter | | false | If true, disable request filtering in the proxy. This is dangerous, and can leave you vulnerable to XSRF attacks, when used with an accessible port. |
| keepalive | | 0s | keepalive specifies the keep-alive period for an active network connection. Set to 0 to disable keepalive. |
| port | p | 8001 | The port on which to run the proxy. Set to 0 to pick a random port. |
| reject-methods | | ^$ | Regular expression for HTTP methods that the proxy should reject (example --reject-methods='POST,PUT,PATCH'). |
| reject-paths | | ^/api/._/pods/._/exec,^/api/._/pods/._/attach | Regular expression for paths that the proxy should reject. Paths specified here will be rejected even accepted by --accept-paths. |
| unix-socket | u | | Unix socket on which to run the proxy. |
| www | w | | Also serve static files from the given directory under the specified prefix. |
| www-prefix | P | /static/ | Prefix to serve static files under, if static file directory is specified. |
* * *
top
===
Display Resource (CPU/Memory) usage.
The top command allows you to see the resource consumption for nodes or pods.
This command requires Metrics Server to be correctly configured and working on the server.
### Usage
`$ kubectl top`
* * *
_node_
------
> Show metrics for all nodes
kubectl top node
> Show metrics for a given node
kubectl top node NODE_NAME
Display resource (CPU/memory) usage of nodes.
The top-node command allows you to see the resource consumption of nodes.
### Usage
`$ kubectl top node [NAME | -l label]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| no-headers | | false | If present, print output without headers |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-capacity | | false | Print node resources based on Capacity instead of Allocatable(default) of the nodes. |
| sort-by | | | If non-empty, sort nodes list using specified field. The field can be either 'cpu' or 'memory'. |
| use-protocol-buffers | | true | Enables using protocol-buffers to access Metrics API. |
* * *
_pod_
-----
> Show metrics for all pods in the default namespace
kubectl top pod
> Show metrics for all pods in the given namespace
kubectl top pod --namespace=NAMESPACE
> Show metrics for a given pod and its containers
kubectl top pod POD_NAME --containers
> Show metrics for the pods defined by label name=myLabel
kubectl top pod -l name=myLabel
Display resource (CPU/memory) usage of pods.
The 'top pod' command allows you to see the resource consumption of pods.
Due to the metrics pipeline delay, they may be unavailable for a few minutes since pod creation.
### Usage
`$ kubectl top pod [NAME | -l label]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-namespaces | A | false | If present, list the requested object(s) across all namespaces. Namespace in current context is ignored even if specified with --namespace. |
| containers | | false | If present, print usage of containers within a pod. |
| field-selector | | | Selector (field query) to filter on, supports '=', '==', and '!='.(e.g. --field-selector key1=value1,key2=value2). The server only supports a limited number of field queries per type. |
| no-headers | | false | If present, print output without headers. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| sort-by | | | If non-empty, sort pods list using specified field. The field can be either 'cpu' or 'memory'. |
| sum | | false | Print the sum of the resource usage |
| use-protocol-buffers | | true | Enables using protocol-buffers to access Metrics API. |
**CLUSTER MANAGEMENT**
======================
* * *
api-versions
============
> Print the supported API versions
kubectl api-versions
Print the supported API versions on the server, in the form of "group/version".
### Usage
`$ kubectl api-versions`
* * *
api-resources
=============
> Print the supported API resources
kubectl api-resources
> Print the supported API resources with more information
kubectl api-resources -o wide
> Print the supported API resources sorted by a column
kubectl api-resources --sort-by=name
> Print the supported namespaced resources
kubectl api-resources --namespaced=true
> Print the supported non-namespaced resources
kubectl api-resources --namespaced=false
> Print the supported API resources with a specific APIGroup
kubectl api-resources --api-group=rbac.authorization.k8s.io
Print the supported API resources on the server.
### Usage
`$ kubectl api-resources`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| api-group | | | Limit to resources in the specified API group. |
| cached | | false | Use the cached list of resources if available. |
| categories | | \[\] | Limit to resources that belong the the specified categories. |
| namespaced | | true | If false, non-namespaced resources will be returned, otherwise returning namespaced resources by default. |
| no-headers | | false | When using the default or custom-column output format, don't print headers (default print headers). |
| output | o | | Output format. One of: (wide, name). |
| sort-by | | | If non-empty, sort list of resources using specified field. The field can be either 'name' or 'kind'. |
| verbs | | \[\] | Limit to resources that support the specified verbs. |
* * *
certificate
===========
Modify certificate resources.
### Usage
`$ kubectl certificate SUBCOMMAND`
* * *
_approve_
---------
> Approve CSR 'csr-sqgzp'
kubectl certificate approve csr-sqgzp
Approve a certificate signing request.
kubectl certificate approve allows a cluster admin to approve a certificate signing request (CSR). This action tells a certificate signing controller to issue a certificate to the requestor with the attributes requested in the CSR.
SECURITY NOTICE: Depending on the requested attributes, the issued certificate can potentially grant a requester access to cluster resources or to authenticate as a requested identity. Before approving a CSR, ensure you understand what the signed certificate can do.
### Usage
`$ kubectl certificate approve (-f FILENAME | NAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to update |
| force | | false | Update the CSR even if it is already approved. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
_deny_
------
> Deny CSR 'csr-sqgzp'
kubectl certificate deny csr-sqgzp
Deny a certificate signing request.
kubectl certificate deny allows a cluster admin to deny a certificate signing request (CSR). This action tells a certificate signing controller to not to issue a certificate to the requestor.
### Usage
`$ kubectl certificate deny (-f FILENAME | NAME)`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| filename | f | \[\] | Filename, directory, or URL to files identifying the resource to update |
| force | | false | Update the CSR even if it is already denied. |
| kustomize | k | | Process the kustomization directory. This flag can't be used together with -f or -R. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| recursive | R | false | Process the directory used in -f, --filename recursively. Useful when you want to manage related manifests organized within the same directory. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
cluster-info
============
> Print the address of the control plane and cluster services
kubectl cluster-info
Display addresses of the control plane and services with label kubernetes.io/cluster-service=true. To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
### Usage
`$ kubectl cluster-info`
* * *
_dump_
------
> Dump current cluster state to stdout
kubectl cluster-info dump
> Dump current cluster state to /path/to/cluster-state
kubectl cluster-info dump --output-directory=/path/to/cluster-state
> Dump all namespaces to stdout
kubectl cluster-info dump --all-namespaces
> Dump a set of namespaces to /path/to/cluster-state
kubectl cluster-info dump --namespaces default,kube-system --output-directory=/path/to/cluster-state
Dump cluster information out suitable for debugging and diagnosing cluster problems. By default, dumps everything to stdout. You can optionally specify a directory with --output-directory. If you specify a directory, Kubernetes will build a set of files in that directory. By default, only dumps things in the current namespace and 'kube-system' namespace, but you can switch to a different namespace with the --namespaces flag, or specify --all-namespaces to dump all namespaces.
The command also dumps the logs of all of the pods in the cluster; these logs are dumped into different directories based on namespace and pod name.
### Usage
`$ kubectl cluster-info dump`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all-namespaces | A | false | If true, dump all namespaces. If true, --namespaces is ignored. |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| namespaces | | \[\] | A comma separated list of namespaces to dump. |
| output | o | json | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| output-directory | | | Where to output the files. If empty or '-' uses stdout, otherwise creates a directory hierarchy in that directory |
| pod-running-timeout | | 20s | The length of time (like 5s, 2m, or 3h, higher than zero) to wait until at least one pod is running |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
cordon
======
> Mark node "foo" as unschedulable
kubectl cordon foo
Mark node as unschedulable.
### Usage
`$ kubectl cordon NODE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
* * *
drain
=====
> Drain node "foo", even if there are pods not managed by a replication controller, replica set, job, daemon set or stateful set on it
kubectl drain foo --force
> As above, but abort if there are pods not managed by a replication controller, replica set, job, daemon set or stateful set, and use a grace period of 15 minutes
kubectl drain foo --grace-period=900
Drain node in preparation for maintenance.
The given node will be marked unschedulable to prevent new pods from arriving. 'drain' evicts the pods if the API server supports [https://kubernetes.io/docs/concepts/workloads/pods/disruptions/](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/)
eviction [https://kubernetes.io/docs/concepts/workloads/pods/disruptions/](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/)
. Otherwise, it will use normal DELETE to delete the pods. The 'drain' evicts or deletes all pods except mirror pods (which cannot be deleted through the API server). If there are daemon set-managed pods, drain will not proceed without --ignore-daemonsets, and regardless it will not delete any daemon set-managed pods, because those pods would be immediately replaced by the daemon set controller, which ignores unschedulable markings. If there are any pods that are neither mirror pods nor managed by a replication controller, replica set, daemon set, stateful set, or job, then drain will not delete any pods unless you use --force. --force will also allow deletion to proceed if the managing resource of one or more pods is missing.
'drain' waits for graceful termination. You should not operate on the machine until the command completes.
When you are ready to put the node back into service, use kubectl uncordon, which will make the node schedulable again.
[https://kubernetes.io/images/docs/kubectl\_drain.svg](https://kubernetes.io/images/docs/kubectl_drain.svg)
Workflow[https://kubernetes.io/images/docs/kubectl\_drain.svg](https://kubernetes.io/images/docs/kubectl_drain.svg)
### Usage
`$ kubectl drain NODE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| chunk-size | | 500 | Return large lists in chunks rather than all at once. Pass 0 to disable. This flag is beta and may change in the future. |
| delete-emptydir-data | | false | Continue even if there are pods using emptyDir (local data that will be deleted when the node is drained). |
| delete-local-data | | false | Continue even if there are pods using emptyDir (local data that will be deleted when the node is drained). |
| disable-eviction | | false | Force drain to use delete, even if eviction is supported. This will bypass checking PodDisruptionBudgets, use with caution. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| force | | false | Continue even if there are pods that do not declare a controller. |
| grace-period | | \-1 | Period of time in seconds given to each pod to terminate gracefully. If negative, the default value specified in the pod will be used. |
| ignore-daemonsets | | false | Ignore DaemonSet-managed pods. |
| pod-selector | | | Label selector to filter pods on the node |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| skip-wait-for-delete-timeout | | 0 | If pod DeletionTimestamp older than N seconds, skip waiting for the pod. Seconds must be greater than 0 to skip. |
| timeout | | 0s | The length of time to wait before giving up, zero means infinite |
* * *
taint
=====
> Update node 'foo' with a taint with key 'dedicated' and value 'special-user' and effect 'NoSchedule' # If a taint with that key and effect already exists, its value is replaced as specified
kubectl taint nodes foo dedicated=special-user:NoSchedule
> Remove from node 'foo' the taint with key 'dedicated' and effect 'NoSchedule' if one exists
kubectl taint nodes foo dedicated:NoSchedule-
> Remove from node 'foo' all the taints with key 'dedicated'
kubectl taint nodes foo dedicated-
> Add a taint with key 'dedicated' on nodes having label mylabel=X
kubectl taint node -l myLabel=X dedicated=foo:PreferNoSchedule
> Add to node 'foo' a taint with key 'bar' and no value
kubectl taint nodes foo bar:NoSchedule
Update the taints on one or more nodes.
_A taint consists of a key, value, and effect. As an argument here, it is expressed as key=value:effect.
_The key must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to 253 characters.
_Optionally, the key can begin with a DNS subdomain prefix and a single '/', like example.com/my-app.
_The value is optional. If given, it must begin with a letter or number, and may contain letters, numbers, hyphens, dots, and underscores, up to 63 characters.
_The effect must be NoSchedule, PreferNoSchedule or NoExecute.
_Currently taint can only apply to node.
### Usage
`$ kubectl taint NODE NAME KEY_1=VAL_1:TAINT_EFFECT_1 ... KEY_N=VAL_N:TAINT_EFFECT_N`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| all | | false | Select all nodes in the cluster |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| field-manager | | kubectl-taint | Name of the manager used to track field ownership. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| overwrite | | false | If true, allow taints to be overwritten, otherwise reject taint updates that overwrite existing taints. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
| validate | | strict | Must be one of: strict (or true), warn, ignore (or false). "true" or "strict" will use a schema to validate the input and fail the request if invalid. It will perform server side validation if ServerSideFieldValidation is enabled on the api-server, but will fall back to less reliable client-side validation if not. "warn" will warn about unknown or duplicate fields without blocking the request if server-side field validation is enabled on the API server, and behave as "ignore" otherwise. "false" or "ignore" will not perform any schema validation, silently dropping any unknown or duplicate fields. |
* * *
uncordon
========
> Mark node "foo" as schedulable
kubectl uncordon foo
Mark node as schedulable.
### Usage
`$ kubectl uncordon NODE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| dry-run | | none | Must be "none", "server", or "client". If client strategy, only print the object that would be sent, without sending it. If server strategy, submit server-side request without persisting the resource. |
| selector | l | | Selector (label query) to filter on, supports '=', '==', and '!='.(e.g. -l key1=value1,key2=value2). Matching objects must satisfy all of the specified label constraints. |
**KUBECTL SETTINGS AND USAGE**
==============================
* * *
alpha
=====
These commands correspond to alpha features that are not enabled in Kubernetes clusters by default.
### Usage
`$ kubectl alpha`
* * *
_auth_
------
Inspect authorization
### Usage
`$ kubectl alpha auth`
* * *
_auth whoami_
-------------
> Get your subject attributes.
kubectl alpha auth whoami
> Get your subject attributes in JSON format.
kubectl alpha auth whoami -o json
Experimental: Check who you are and your attributes (groups, extra).
This command is helpful to get yourself aware of the current user attributes, especially when dynamic authentication, e.g., token webhook, auth proxy, or OIDC provider, is enabled in the Kubernetes cluster.
### Usage
`$ kubectl alpha auth whoami`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| output | o | | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
completion
==========
> Installing bash completion on macOS using homebrew ## If running Bash 3.2 included with macOS
brew install bash-completion
> or, if running Bash 4.1+
brew install bash-completion@2
> If kubectl is installed via homebrew, this should start working immediately ## If you've installed via other means, you may need add the completion to your completion directory
kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/kubectl
> Installing bash completion on Linux ## If bash-completion is not installed on Linux, install the 'bash-completion' package ## via your distribution's package manager. ## Load the kubectl completion code for bash into the current shell
source <(kubectl completion bash)
> Write bash completion code to a file and source it from .bash\_profile
kubectl completion bash > ~/.kube/completion.bash.inc
printf "
> Kubectl shell completion
source '$HOME/.kube/completion.bash.inc'
" >> $HOME/.bash_profile
source $HOME/.bash_profile
> Load the kubectl completion code for zsh\[1\] into the current shell
source <(kubectl completion zsh)
> Set the kubectl completion code for zsh\[1\] to autoload on startup
kubectl completion zsh > "${fpath[1]}/_kubectl"
> Load the kubectl completion code for fish\[2\] into the current shell
kubectl completion fish | source
> To load completions for each session, execute once:
kubectl completion fish > ~/.config/fish/completions/kubectl.fish
> Load the kubectl completion code for powershell into the current shell
kubectl completion powershell | Out-String | Invoke-Expression
> Set kubectl completion code for powershell to run on startup ## Save completion code to a script and execute in the profile
kubectl completion powershell > $HOME\.kube\completion.ps1
Add-Content $PROFILE "$HOME\.kube\completion.ps1"
> Execute completion code in the profile
Add-Content $PROFILE "if (Get-Command kubectl -ErrorAction SilentlyContinue) {
kubectl completion powershell | Out-String | Invoke-Expression
}"
> Add completion code directly to the $PROFILE script
kubectl completion powershell >> $PROFILE
Output shell completion code for the specified shell (bash, zsh, fish, or powershell). The shell code must be evaluated to provide interactive completion of kubectl commands. This can be done by sourcing it from the .bash\_profile.
Detailed instructions on how to do this are available here:
for macOS:
[https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-shell-autocompletion](https://kubernetes.io/docs/tasks/tools/install-kubectl-macos/#enable-shell-autocompletion)
for linux:
[https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-shell-autocompletion](https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/#enable-shell-autocompletion)
for windows:
[https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/#enable-shell-autocompletion](https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/#enable-shell-autocompletion)
Note for zsh users: \[1\] zsh completions are only supported in versions of zsh >= 5.2.
### Usage
`$ kubectl completion SHELL`
* * *
config
======
Modify kubeconfig files using subcommands like "kubectl config set current-context my-context"
The loading order follows these rules:
1\. If the --kubeconfig flag is set, then only that file is loaded. The flag may only be set once and no merging takes place.
2\. If $KUBECONFIG environment variable is set, then it is used as a list of paths (normal path delimiting rules for your system). These paths are merged. When a value is modified, it is modified in the file that defines the stanza. When a value is created, it is created in the first file that exists. If no files in the chain exist, then it creates the last file in the list.
3\. Otherwise, ${HOME}/.kube/config is used and no merging takes place.
### Usage
`$ kubectl config SUBCOMMAND`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| kubeconfig | | | use a particular kubeconfig file |
* * *
_current-context_
-----------------
> Display the current-context
kubectl config current-context
Display the current-context.
### Usage
`$ kubectl config current-context`
* * *
_delete-cluster_
----------------
> Delete the minikube cluster
kubectl config delete-cluster minikube
Delete the specified cluster from the kubeconfig.
### Usage
`$ kubectl config delete-cluster NAME`
* * *
_delete-context_
----------------
> Delete the context for the minikube cluster
kubectl config delete-context minikube
Delete the specified context from the kubeconfig.
### Usage
`$ kubectl config delete-context NAME`
* * *
_delete-user_
-------------
> Delete the minikube user
kubectl config delete-user minikube
Delete the specified user from the kubeconfig.
### Usage
`$ kubectl config delete-user NAME`
* * *
_get-clusters_
--------------
> List the clusters that kubectl knows about
kubectl config get-clusters
Display clusters defined in the kubeconfig.
### Usage
`$ kubectl config get-clusters`
* * *
_get-contexts_
--------------
> List all the contexts in your kubeconfig file
kubectl config get-contexts
> Describe one context in your kubeconfig file
kubectl config get-contexts my-context
Display one or many contexts from the kubeconfig file.
### Usage
`$ kubectl config get-contexts [(-o|--output=)name)]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| no-headers | | false | When using the default or custom-column output format, don't print headers (default print headers). |
| output | o | | Output format. One of: (name). |
* * *
_get-users_
-----------
> List the users that kubectl knows about
kubectl config get-users
Display users defined in the kubeconfig.
### Usage
`$ kubectl config get-users`
* * *
_rename-context_
----------------
> Rename the context 'old-name' to 'new-name' in your kubeconfig file
kubectl config rename-context old-name new-name
Renames a context from the kubeconfig file.
CONTEXT\_NAME is the context name that you want to change.
NEW\_NAME is the new name you want to set.
Note: If the context being renamed is the 'current-context', this field will also be updated.
### Usage
`$ kubectl config rename-context CONTEXT_NAME NEW_NAME`
* * *
_set_
-----
> Set the server field on the my-cluster cluster to [https://1.2.3.4](https://1.2.3.4/)
kubectl config set clusters.my-cluster.server https://1.2.3.4
> Set the certificate-authority-data field on the my-cluster cluster
kubectl config set clusters.my-cluster.certificate-authority-data $(echo "cert_data_here" | base64 -i -)
> Set the cluster field in the my-context context to my-cluster
kubectl config set contexts.my-context.cluster my-cluster
> Set the client-key-data field in the cluster-admin user using --set-raw-bytes option
kubectl config set users.cluster-admin.client-key-data cert_data_here --set-raw-bytes=true
Set an individual value in a kubeconfig file.
PROPERTY\_NAME is a dot delimited name where each token represents either an attribute name or a map key. Map keys may not contain dots.
PROPERTY\_VALUE is the new value you want to set. Binary fields such as 'certificate-authority-data' expect a base64 encoded string unless the --set-raw-bytes flag is used.
Specifying an attribute name that already exists will merge new fields on top of existing values.
### Usage
`$ kubectl config set PROPERTY_NAME PROPERTY_VALUE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| set-raw-bytes | | false | When writing a \[\]byte PROPERTY\_VALUE, write the given string directly without base64 decoding. |
* * *
_set-cluster_
-------------
> Set only the server field on the e2e cluster entry without touching other values
kubectl config set-cluster e2e --server=https://1.2.3.4
> Embed certificate authority data for the e2e cluster entry
kubectl config set-cluster e2e --embed-certs --certificate-authority=~/.kube/e2e/kubernetes.ca.crt
> Disable cert checking for the e2e cluster entry
kubectl config set-cluster e2e --insecure-skip-tls-verify=true
> Set custom TLS server name to use for validation for the e2e cluster entry
kubectl config set-cluster e2e --tls-server-name=my-cluster-name
> Set proxy url for the e2e cluster entry
kubectl config set-cluster e2e --proxy-url=https://1.2.3.4
Set a cluster entry in kubeconfig.
Specifying a name that already exists will merge new fields on top of existing values for those fields.
### Usage
`$ kubectl config set-cluster NAME [--server=server] [--certificate-authority=path/to/certificate/authority] [--insecure-skip-tls-verify=true] [--tls-server-name=example.com]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| certificate-authority | | | Path to certificate-authority file for the cluster entry in kubeconfig |
| embed-certs | | false | embed-certs for the cluster entry in kubeconfig |
| insecure-skip-tls-verify | | false | insecure-skip-tls-verify for the cluster entry in kubeconfig |
| proxy-url | | | proxy-url for the cluster entry in kubeconfig |
| server | | | server for the cluster entry in kubeconfig |
| tls-server-name | | | tls-server-name for the cluster entry in kubeconfig |
* * *
_set-context_
-------------
> Set the user field on the gce context entry without touching other values
kubectl config set-context gce --user=cluster-admin
Set a context entry in kubeconfig.
Specifying a name that already exists will merge new fields on top of existing values for those fields.
### Usage
`$ kubectl config set-context [NAME | --current] [--cluster=cluster_nickname] [--user=user_nickname] [--namespace=namespace]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| cluster | | | cluster for the context entry in kubeconfig |
| current | | false | Modify the current context |
| namespace | | | namespace for the context entry in kubeconfig |
| user | | | user for the context entry in kubeconfig |
* * *
_set-credentials_
-----------------
> Set only the "client-key" field on the "cluster-admin" # entry, without touching other values
kubectl config set-credentials cluster-admin --client-key=~/.kube/admin.key
> Set basic auth for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --username=admin --password=uXFGweU9l35qcif
> Embed client certificate data in the "cluster-admin" entry
kubectl config set-credentials cluster-admin --client-certificate=~/.kube/admin.crt --embed-certs=true
> Enable the Google Compute Platform auth provider for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --auth-provider=gcp
> Enable the OpenID Connect auth provider for the "cluster-admin" entry with additional args
kubectl config set-credentials cluster-admin --auth-provider=oidc --auth-provider-arg=client-id=foo --auth-provider-arg=client-secret=bar
> Remove the "client-secret" config value for the OpenID Connect auth provider for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --auth-provider=oidc --auth-provider-arg=client-secret-
> Enable new exec auth plugin for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --exec-command=/path/to/the/executable --exec-api-version=client.authentication.k8s.io/v1beta1
> Define new exec auth plugin args for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --exec-arg=arg1 --exec-arg=arg2
> Create or update exec auth plugin environment variables for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --exec-env=key1=val1 --exec-env=key2=val2
> Remove exec auth plugin environment variables for the "cluster-admin" entry
kubectl config set-credentials cluster-admin --exec-env=var-to-remove-
Set a user entry in kubeconfig.
Specifying a name that already exists will merge new fields on top of existing values.
Client-certificate flags: --client-certificate=certfile --client-key=keyfile
Bearer token flags: --token=bearer\_token
Basic auth flags: --username=basic\_user --password=basic\_password
Bearer token and basic auth are mutually exclusive.
### Usage
`$ kubectl config set-credentials NAME [--client-certificate=path/to/certfile] [--client-key=path/to/keyfile] [--token=bearer_token] [--username=basic_user] [--password=basic_password] [--auth-provider=provider_name] [--auth-provider-arg=key=value] [--exec-command=exec_command] [--exec-api-version=exec_api_version] [--exec-arg=arg] [--exec-env=key=value]`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| auth-provider | | | Auth provider for the user entry in kubeconfig |
| auth-provider-arg | | \[\] | 'key=value' arguments for the auth provider |
| client-certificate | | | Path to client-certificate file for the user entry in kubeconfig |
| client-key | | | Path to client-key file for the user entry in kubeconfig |
| embed-certs | | false | Embed client cert/key for the user entry in kubeconfig |
| exec-api-version | | | API version of the exec credential plugin for the user entry in kubeconfig |
| exec-arg | | \[\] | New arguments for the exec credential plugin command for the user entry in kubeconfig |
| exec-command | | | Command for the exec credential plugin for the user entry in kubeconfig |
| exec-env | | \[\] | 'key=value' environment values for the exec credential plugin |
| password | | | password for the user entry in kubeconfig |
| token | | | token for the user entry in kubeconfig |
| username | | | username for the user entry in kubeconfig |
* * *
_unset_
-------
> Unset the current-context
kubectl config unset current-context
> Unset namespace in foo context
kubectl config unset contexts.foo.namespace
Unset an individual value in a kubeconfig file.
PROPERTY\_NAME is a dot delimited name where each token represents either an attribute name or a map key. Map keys may not contain dots.
### Usage
`$ kubectl config unset PROPERTY_NAME`
* * *
_use-context_
-------------
> Use the context for the minikube cluster
kubectl config use-context minikube
Set the current-context in a kubeconfig file.
### Usage
`$ kubectl config use-context CONTEXT_NAME`
* * *
_view_
------
> Show merged kubeconfig settings
kubectl config view
> Show merged kubeconfig settings and raw certificate data and exposed secrets
kubectl config view --raw
> Get the password for the e2e user
kubectl config view -o jsonpath='{.users[?(@.name == "e2e")].user.password}'
Display merged kubeconfig settings or a specified kubeconfig file.
You can use --output jsonpath={...} to extract specific values using a jsonpath expression.
### Usage
`$ kubectl config view`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| allow-missing-template-keys | | true | If true, ignore any errors in templates when a field or map key is missing in the template. Only applies to golang and jsonpath output formats. |
| flatten | | false | Flatten the resulting kubeconfig file into self-contained output (useful for creating portable kubeconfig files) |
| merge | | true | Merge the full hierarchy of kubeconfig files |
| minify | | false | Remove all information not used by current-context from the output |
| output | o | yaml | Output format. One of: (json, yaml, name, go-template, go-template-file, template, templatefile, jsonpath, jsonpath-as-json, jsonpath-file). |
| raw | | false | Display raw byte data and sensitive data |
| show-managed-fields | | false | If true, keep the managedFields when printing objects in JSON or YAML format. |
| template | | | Template string or path to template file to use when -o=go-template, -o=go-template-file. The template format is golang templates \[[http://golang.org/pkg/text/template/#pkg-overview](http://golang.org/pkg/text/template/#pkg-overview) \]. |
* * *
explain
=======
> Get the documentation of the resource and its fields
kubectl explain pods
> Get the documentation of a specific field of a resource
kubectl explain pods.spec.containers
List the fields for supported resources.
This command describes the fields associated with each supported API resource. Fields are identified via a simple JSONPath identifier:
.\[.\]
Add the --recursive flag to display all of the fields at once without descriptions. Information about each field is retrieved from the server in OpenAPI format.
Use "kubectl api-resources" for a complete list of supported resources.
### Usage
`$ kubectl explain RESOURCE`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| api-version | | | Get different explanations for particular API version (API group/version) |
| recursive | | false | Print the fields of fields (Currently only 1 level deep) |
* * *
options
=======
> Print flags inherited by all commands
kubectl options
Print the list of flags inherited by all commands
### Usage
`$ kubectl options`
* * *
plugin
======
Provides utilities for interacting with plugins.
Plugins provide extended functionality that is not part of the major command-line distribution. Please refer to the documentation and examples for more information about how write your own plugins.
The easiest way to discover and install plugins is via the kubernetes sub-project krew. To install krew, visit [https://krew.sigs.k8s.io/docs/user-guide/setup/install/](https://krew.sigs.k8s.io/docs/user-guide/setup/install/)
krew.sigs.k8s.io [https://krew.sigs.k8s.io/docs/user-guide/setup/install/](https://krew.sigs.k8s.io/docs/user-guide/setup/install/)
### Usage
`$ kubectl plugin [flags]`
* * *
_list_
------
> List all available plugins
kubectl plugin list
List all available plugin files on a user's PATH.
Available plugin files are those that are: - executable - anywhere on the user's PATH - begin with "kubectl-"
### Usage
`$ kubectl plugin list`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| name-only | | false | If true, display only the binary name of each plugin, rather than its full path |
* * *
version
=======
> Print the client and server versions for the current context
kubectl version
Print the client and server version information for the current context.
### Usage
`$ kubectl version`
### Flags
| Name | Shorthand | Default | Usage |
| --- | --- | --- | --- |
| client | | false | If true, shows client version only (no server required). |
| output | o | | One of 'yaml' or 'json'. |
| short | | false | If true, print just the version number. |
---
# Polityki | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/concepts/policy/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/concepts/policy/)
.
Polityki
========
Stosuj polityki do zarządzania bezpieczeństwem i wdrażania najlepszych praktyk.
Polityki Kubernetesa to ustawienia kontrolujące inne konfiguracje lub sposób działania aplikacji w trakcie ich działania. Kubernetes oferuje różne formy polityk, opisane poniżej:
Stosowanie polityk za pomocą obiektów API
-----------------------------------------
Niektóre obiekty API spełniają rolę polityk. Oto kilka przykładów:
* [NetworkPolicies](https://kubernetes.io/docs/concepts/services-networking/network-policies/)
mogą być używane do ograniczania ruchu przychodzącego i wychodzącego dla workload.
* [LimitRanges](https://kubernetes.io/docs/concepts/policy/limit-range/)
zarządzają ograniczeniami alokacji zasobów w różnych typach obiektów.
* [ResourceQuotas](https://kubernetes.io/docs/concepts/policy/resource-quotas/)
ogranicza zużycie zasobów dla [namespace](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/namespaces "An abstraction used by Kubernetes to support isolation of groups of resources within a single cluster.")
.
Stosowanie polityk za pomocą kontrolerów dopuszczania (ang. Admission Controllers)
----------------------------------------------------------------------------------
Kontroler dopuszczania (ang. Admission Controller - [admission controller](https://kubernetes.io/pl/docs/reference/access-authn-authz/admission-controllers/ "A piece of code that intercepts requests to the Kubernetes API server prior to persistence of the object.")
) działa na serwerze API i może weryfikować lub modyfikować żądania API. Niektóre takie kontrolery działają w celu zastosowania polityk. Na przykład kontroler [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
modyfikuje nowy Pod, aby ustawić politykę pobierania obrazów na `Always`.
Kubernetes ma kilka wbudowanych kontrolerów dostępu, które można konfigurować za pomocą flagi `--enable-admission-plugins` serwera API.
Szczegóły dotyczące kontrolerów dopuszczania są udokumentowane w dedykowanej sekcji:
* [Kontrolery dopuszczania (ang. Admission Controllers)](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)
Stosowanie polityk używając ValidatingAdmissionPolicy
-----------------------------------------------------
Polityki walidacji przyjmowania (ang. Validating admission policies) umożliwiają wykonywanie konfigurowalnych kontroli walidacji na serwerze API przy użyciu wspólnego języka wyrażeń (CEL). Na przykład, `ValidatingAdmissionPolicy` może być używana do zakazania użycia tagu obrazu `latest`.
Polityka `ValidatingAdmissionPolicy` działa na żądaniach API i może być używana do blokowania, audytowania oraz ostrzegania użytkowników o niezgodnych konfiguracjach.
Szczegóły dotyczące API `ValidatingAdmissionPolicy`, wraz z przykładami, są udokumentowane w dedykowanej sekcji:
* [Walidacja Polityki Dopuszczania (ang. Validating Admission Policy)](https://kubernetes.io/docs/reference/access-authn-authz/validating-admission-policy/)
Stosowanie polityk przy użyciu dynamicznej kontroli dostępu
-----------------------------------------------------------
Dynamiczne kontrolery dostępu (lub webhooki dostępu) działają poza serwerem API jako oddzielne aplikacje, które rejestrują się do odbierania żądań webhooków w celu przeprowadzania weryfikacji lub modyfikacji żądań API.
Dynamiczne kontrolery dopuszczeń mogą być używane do stosowania polityk na żądaniach API i uruchamiania innych procesów opartych na politykach. Dynamiczny kontroler dopuszczeń może przeprowadzać skomplikowane kontrole, w tym te, które wymagają pobierania innych zasobów klastra i danych zewnętrznych. Na przykład, kontrola weryfikacji obrazu może wyszukiwać dane z rejestrów OCI, aby zatwierdzić podpisy i atestacje obrazów kontenerów.
Szczegóły dotyczące dynamicznej kontroli dostępu są udokumentowane w dedykowanej sekcji:
* [Dynamiczne Sterowanie Dostępem](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/)
### Implementacje
**Informacja:** Ta sekcja przekierowuje do projektów zewnętrznych (niżej ich lista alfabetyczna), które udostępniają funkcjonalności wymagane przez Kubernetesa. Autorzy Kubernetesa nie odpowiadają za te projekty. Jeśli chcesz dodać projekt do tego wykazu, zanim wprowadzisz zmiany, przeczytaj [nasz przewodnik](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)
.
Dynamiczne kontrolery dopuszczeń (Admission Controllers), które działają jako elastyczne silniki polityki, są rozwijane w ekosystemie Kubernetesa:
* [Kubewarden](https://github.com/kubewarden)
* [Kyverno](https://kyverno.io/)
* [OPA Gatekeeper](https://github.com/open-policy-agent/gatekeeper)
* [Polaris](https://polaris.docs.fairwinds.com/admission-controller/)
Stosowanie zasad za pomocą konfiguracji Kubelet
-----------------------------------------------
Kubernetes pozwala na konfigurowanie Kubelet na każdym węźle roboczym. Niektóre konfiguracje Kubelet działają jako polityki:
* [Limity i rezerwacje identyfikatorów procesów](https://kubernetes.io/docs/concepts/policy/pid-limiting/)
są używane do ograniczania i rezerwacji dostępnych PID-ów.
* [Menedżery zasobów węzła](https://kubernetes.io/docs/concepts/policy/node-resource-managers/)
mogą zarządzać zasobami obliczeniowymi, pamięci oraz urządzeniami dla workloadów krytycznych pod względem opóźnień i o wysokiej przepustowości.
---
# कुबेरनेटेस डॉक्स में योगदान दे | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/contribute/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/contribute/)
.
कुबेरनेटेस डॉक्स में योगदान दे
==============================
* 1: [प्रलेखन शैली अवलोकन](https://kubernetes.io/hi/docs/contribute/_print/#pg-a2d946282df02cdeb47d9f54dfef198e)
* 2: [साइट विश्लेषिकी देखना](https://kubernetes.io/hi/docs/contribute/_print/#pg-ed3187078744c086d64f3d804a926218)
_कुबेरनेटस सभी योगदानकर्ताओ से सुधार का स्वागत करता है चाहे वो नए हो या अनुभवी!_
#### टिप्पणी:
कुबेरनेटस मे योगदान करने के बारे मे अधिक जानकारी के लिए [योगदानकर्ता प्रलेखन](https://www.kubernetes.dev/docs/)
देखें।
इस वेबसाइट की देख रेख [कुबेरनेटस SIG Docs](https://kubernetes.io/hi/docs/contribute/#get-involved-with-sig-docs)
द्वारा की जाती है।
कुबेरनेटस प्रलेखन योगदानकर्ता :
* मौजूदा विषयों को सुधारते हैं
* नए विषय बनाते हैं
* प्रलेखन का अनुवाद करते हैं
* कुबेरनेटस रिलीज चक्र मे प्रलेखन की देख रेख और प्रकाशन करते हैं
शुरू करना
---------
कोई भी प्रलेखन के बारे मे इशू खोल सकता है या कुबेरनेटस वेबसाइट [`kubernetes/website` GitHub रिपॉजिटरी](https://github.com/kubernetes/website)
मे बदलाव पुल अनुरोध (PR) द्वारा कर सकता है। आपको [Git](https://git-scm.com/)
और [Github](https://skills.github.com/)
की जानकारी होनी चाहिए ताकि आप कुबेरनेटेस समुदाय मे प्रभावी रूप से काम कर सकें।
प्रलेखन मे सहयोग करने के लिए:
1. [योगदानकर्ता समझौता लाइसेन्स](https://github.com/kubernetes/community/blob/master/CLA.md)
पर हस्ताक्षर करें।
2. [प्रलेखन रिपॉजिटरी](https://github.com/kubernetes/website)
और वेबसाइट की [स्टैटिक साइट जनरेटर](https://gohugo.io/)
से खुद को परिचित करें।
3. सुनिश्चित करें की आपको [पुल अनुरोध करना](https://kubernetes.io/docs/contribute/new-content/open-a-pr/)
और [बदलाओ की समीक्षा](https://kubernetes.io/docs/contribute/review/reviewing-prs/)
करना आता हो।
flowchart TB subgraph third\[PR ओपन करे\] direction TB U\[ \] -.- Q\[विषय सुधारे\] --- N\[विषय निर्माण करे\] N --- O\[डॉक्स का अनुवाद करे\] O --- P\[K8s रिलीज़ चक्र के प्रलेखन \
को संचालित /प्रकाशित करें\] end subgraph second\[समीक्षा\] direction TB T\[ \] -.- D\[kubernetes/website \
रिपॉजिटरी \
को देखें\] --- E\[Hugo स्टैटिक साइट \
जनरेटर \
को देखें\] E --- F\[मूलभूत GitHub \
कमांड समझें\] F --- G\[ओपन PR की समीक्षा करे \
और समीक्षा प्रक्रिया \
को बदलें\] end subgraph first\[साइनअप\] direction TB S\[ \] -.- B\[CNCF \
योगदानकर्ता \
लइसेंस समझौता \
पर हस्ताक्षर करें\] --- C\[sig-docs स्लैक चैनल \
में जुड़ें\] C --- V\[kubernetes-sig-docs \
मेलिंग लिस्ट में जुड़ें\] V --- M\[साप्ताहिक \
sig-docs कॉल \
या स्लैक बैठक में शामिल हों\] end A(\[fa:fa-user नए \
योगदानकर्ता\]) --> first A --> second A --> third A --> H\[सवाल पूछे!!!\] classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000 class A,B,C,D,E,F,G,H,M,Q,N,O,P,V grey class S,T,U spacewhite class first,second,third white
_**आकृति - नए योगदानकर्ताओं के लिए योगदान शुरू करने का रास्ता**_
ऊपर दी गई आकृति नए योगदानकर्ता के लिए दिशानिर्देश हैं। `Sign up` या `review` के लिए आप इनमे से कुछ या सभी निर्देशों का पालन कर सकते हैं। अब आप PR ओपन करने के लिए तैयार हैं जो आपके योगदान के उद्देश को पूरा करे जो `Open PR` खंड मे सूचीबद्ध हैं। आपके सभी प्रश्नों का सदैव स्वागत है।
कुबेरनेटस समुदाय मे कुछ कार्यों के लिए अधिक विश्वास और अभिगम की आवश्यकता होती है। भूमिका और अनुमति के बारे मे ज्यादा जानकारी के लिए
[SIG Docs मे भाग लेना](https://kubernetes.io/docs/contribute/participate/)
को देखें।
आपका पहला योगदान
----------------
आप अपने पहले योगदान की तैयारी के लिए दिए गए दिशानिर्देश को देख सकते हैं। नीचे दिया हुआ चित्र दिशानिर्देश और उसकी विस्तार मे जानकारी देता है।
flowchart LR subgraph second\[पहला योगदान\] direction TB S\[ \] -.- G\[दूसरे K8s मेम्बर्स के \
PRs की समीक्षा करें\] --> A\[अपने पहले इशू (गुफ फर्स्ट इशू) \
के लिए kubernetes/website \
की इशू सूची पर जाएं\] --> B\[PR ओपन करें!!\] end subgraph first\[सूचित तैयारी\] direction TB T\[ \] -.- D\[योगदान अवलोकन को पढे\] -->E\[K8s विषय \
और विषय गाइड को पढ़ें\] E --> F\[Hugo पेज \
विषय के प्रकार \
और shortcodes के बारे मे जाने\] end first ----> second classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000 class A,B,D,E,F,G grey class S,T spacewhite class first,second white
**आकृति - आपके पहले योगदान की तैयारी**
* योगदान करने के विभिन्न तरीकों को जानने के लिए [योगदानकर्ता अवलोकन](https://kubernetes.io/docs/contribute/new-content/overview/)
को पढ़ें।
* अच्छे प्रवेश बिन्दु के लिए [`kubernetes/website` इशू सूची](https://github.com/kubernetes/website/issues/)
को जाचें।
* मौजूदा प्रलेखन पर [Github का प्रयोग करते हुए पुल अनुरोध करॆ](https://kubernetes.io/docs/contribute/new-content/open-a-pr/#changes-using-github)
और इशू दाखिल करने के बारे मे अधिक जानें।
* भाषा और सटीकता के लिए अन्य कुबेरनेटस समुदाय के सदस्यों के [पुल अनुरोध की समीक्षा करें](https://kubernetes.io/docs/contribute/review/reviewing-prs/)
।
* कुबेरनेटस [प्रकरण](https://kubernetes.io/docs/contribute/style/content-guide/)
और
[स्टाइल मार्गदर्शक](https://kubernetes.io/docs/contribute/style/style-guide/)
को पढ़ें ताकि आप सूचित टिप्पणी दे सकें।
* [पेज प्रलेखन टाइप](https://kubernetes.io/docs/contribute/style/page-content-types/)
और [Hugo shortcodes](https://kubernetes.io/docs/contribute/style/hugo-shortcodes/)
के बारे मे जानें।
अगले कदम
--------
* रिपॉजिटरी के [लोकल क्लोन से काम करना](https://kubernetes.io/docs/contribute/new-content/open-a-pr/#fork-the-repo)
सीखें।
* [रिलीज़ में फीचर्स का](https://kubernetes.io/docs/contribute/new-content/new-features/)
आलेख करे।
* [SIG Docs](https://kubernetes.io/docs/contribute/participate/)
मे भाग लें और [सदस्य या समीक्षक](https://kubernetes.io/docs/contribute/participate/roles-and-responsibilities/)
बनें।
* [स्थानीयकरण](https://kubernetes.io/docs/contribute/localization/)
शुरू करे या उसमे सहायता करें।
सिग डॉक्स मे शामिल हो
---------------------
[SIG Docs](https://kubernetes.io/docs/contribute/participate/)
योगदानकर्ताओ का एक समूह है जो कुबेरनेटेस प्रलेखन और वेबसाईट की देख रेख और उसे प्रकाशित करता है। SIG Docs मे शामिल होना कुबेरनेटस योगदानकर्ताओ (फीचर विकास या उससे अन्यथा) के लिए कुबेरनेटस परियोजना पर प्रभाव डालने का बेहतरीन तरीका है।
SIG Docs भिन्न प्रकार से संवाद करते हैं:
* [कुबेरनेटेस Slack चैनल मे #sig-docs से जुड़ें](https://slack.k8s.io/)
और खुद का परिचय दें!
* [kubernetes-sig-docs मेलिंग लिस्ट मे शामिल हो](https://groups.google.com/forum/#!forum/kubernetes-sig-docs)
, वहाँ व्यापक विचार-विमर्श होता है और आधिकारिक फैसले का अभिलेखन किया जाता है।
* [SIG Docs विडिओ बैठक](https://github.com/kubernetes/community/tree/master/sig-docs)
मे शामिल हो जो हर दो सप्ताह मे होती है। बैठक की घोषणा हमेशा `#sig-docs` पर की जाती है और [कुबेरनेटेस समुदाय बैठक कैलंडर](https://calendar.google.com/calendar/embed?src=cgnt364vd8s86hr2phapfjc6uk%40group.calendar.google.com&ctz=America/Los_Angeles)
में जोड़ दिया जाता है। आपको [Zoom client](https://zoom.us/download)
डाउनलोड करने की जरूरत पड़ेगी या फोन की मदद से भी डायल कर सकते हैं।
* जिन सप्ताह मे Zoom बैठक नहीं हुई हो तब SIG Docs अतुल्यकालिक बैठक को जॉइन करे जो Slack पर होती है। बैठक की घोषणा हमेशा `#sig-docs` पर होती है। बैठक की घोषणा के बाद आप किसी भी सूत्र मे 24 घंटे तक योगदान कर सकते है।
योगदान करने के अन्य तरीके
-------------------------
* [कुबेरनेटस समुदाय साइट](https://kubernetes.io/community/)
पर जाए। Twitter या Slack Overflow मैं भाग ले, कुबेरनेटस स्थानीय आयोजन और मिलन के बारे मे जाने ।
* कुबेरनेटस फीचर विकास में शामिल होने के लिए [योगदानकर्ता चीटशीट](https://www.kubernetes.dev/docs/contributor-cheatsheet/)
पढ़ें।
* [कुबेरनेटस योगदानकर्ता](https://www.kubernetes.dev/)
और [अतिरिक्त योगदानकर्ता साधन](https://www.kubernetes.dev/resources/)
के बारे मे अधिक जानकारी के लिए योगदानकर्ता साइट पर जाएं।
* [ब्लॉग पोस्ट या केस अध्ययन](https://kubernetes.io/docs/contribute/new-content/blogs-case-studies/)
प्रस्तुत करे।
1 - प्रलेखन शैली अवलोकन
=======================
इस खंड के विषय लेखन शैली, सामग्री स्वरूपण, और संगठन, और कुबेरनेट्स प्रलेखन के लिए विशिष्ट Hugo अनुकूलन का उपयोग करने पर मार्गदर्शन प्रदान करते हैं।
2 - साइट विश्लेषिकी देखना
=========================
इस पृष्ठ में Kubernetes.io विश्लेषिकी डैशबोर्ड के बारे में जानकारी है।
[डैशबोर्ड देखें](https://datastudio.google.com/reporting/fede2672-b2fd-402a-91d2-7473bdb10f04)
।
यह डैशबोर्ड Google Data Studio का उपयोग करके बनाया गया है और Google Analytics का उपयोग करके Kubernetes.io पर एकत्रित जानकारी दिखाता है।
### डैशबोर्ड का उपयोग करना
डिफ़ॉल्ट रूप से, डैशबोर्ड पिछले 30 दिनों के सभी एकत्रित विश्लेषण दिखाता है। विभिन्न दिनांक सीमा मे आने वाला डेटा देखने के लिए date selector का उपयोग करें। अन्य फ़िल्टरिंग विकल्प आपको उपयोगकर्ता का स्थान, साइट तक पहुंचने के लिए उपयोग किए जाने वाले उपकरण, उपयोग किए गए दस्तावेज़ों के अनुवाद, और बहुत से चीज़ों का डेटा देखने की अनुमति देते हैं।
यदि आप इस डैशबोर्ड में कोई समस्या देखते हैं, या किसी सुधार का अनुरोध करना चाहते हैं, तो कृपया [एक इशू बनाएं](https://github.com/kubernetes/website/issues/new/choose)
।
---
# Styl dokumentacji | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/contribute/style/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/contribute/style/)
.
Styl dokumentacji
=================
* 1: [Typy treści](https://kubernetes.io/pl/docs/contribute/style/_print/#pg-69e79c7baae79b2f34332a745d62ddca)
Tematy w tej sekcji zawierają wskazówki dotyczące stylu pisania, formatowania treści i organizacji, a także korzystania ze specyficznych dostosowań Hugo dla dokumentacji Kubernetesa.
1 - Typy treści
===============
Dokumentacja Kubernetesa obejmuje kilka typów treści stron:
* Pojęcia i koncepcje (ang. Concept)
* Zadanie (ang. Task)
* Samouczek (ang. Tutorial)
* Materiały źródłowe (ang. Reference)
Sekcje treści
-------------
Każdy typ strony zawiera szereg sekcji zdefiniowanych przez komentarze Markdown i nagłówki HTML. Możesz dodać nagłówki do swojej strony za pomocą kodu `heading`. Komentarze i nagłówki pomagają utrzymać odpowiednią strukturę strony dla danego typu.
Przykłady komentarzy w Markdown definiujących sekcje strony:
Aby utworzyć typowe nagłówki na swoich stronach, użyj kodu `heading` z nazwą nagłówka.
Przykłady nazw nagłówków:
* whatsnext - co dalej
* prerequisites - wymagania wstępne
* objectives - cele
* cleanup - sprzątanie
* synopsis - streszczenie
* seealso - zobacz także
* options - opcje
Na przykład, aby utworzyć nagłówek `whatsnext`, dodaj kod nagłówka z nazwą "whatsnext":
## {{% heading "whatsnext" %}}
Możesz zadeklarować nagłówek `prerequisites` w następujący sposób:
## {{% heading "prerequisites" %}}
Kod `heading` oczekuje jednego parametru typu string. Ten parametr nagłówka odpowiada prefiksowi zmiennej w plikach `i18n//.toml`. Na przykład:
`i18n/en/en.toml`:
[whatsnext_heading]
other = "What's next"
`i18n/ko/ko.toml`:
[whatsnext_heading]
other = "다음 내용"
Typy zawartości
---------------
Każdy typ zawartości nieformalnie definiuje swoją oczekiwaną strukturę strony. Twórz zawartość strony, korzystając z sugerowanych sekcji strony.
### Pojęcie (ang. Concept)
Strona z pojęciami wyjaśnia określony aspekt Kubernetesa. Na przykład, strona koncepcyjna może opisywać obiekt Deployment w Kubernetesie i wyjaśniać jego rolę jako aplikacji po wdrożeniu, skalowaniu i aktualizacji. Zazwyczaj strony koncepcyjne nie zawierają instrukcji krok po kroku, lecz odsyłają do zadań lub samouczków.
Aby napisać nową stronę z pojęciem, utwórz plik Markdown w podkatalogu katalogu `/content/en/docs/concepts`, z następującymi sekcjami:
Strony koncepcyjne są podzielone na trzy sekcje:
| Sekcja strony |
| --- |
| overview - przegląd |
| body - treść |
| whatsnext - co dalej |
Sekcje `overview` i `body` pojawiają się jako komentarze na stronie z koncepcjami. Możesz dodać sekcję `whatsnext` do swojej strony za pomocą kodu `heading`.
Wypełnij każdą sekcję treścią. Postępuj zgodnie z tymi wytycznymi:
* Organizuj treści za pomocą nagłówków H2 i H3.
* Dla `overview`, ustaw kontekst tematu za pomocą pojedynczego akapitu.
* Dla `body` wyjaśnij koncepcję.
* Dla `whatsnext`, podaj wypunktowaną listę tematów (maksymalnie 5), aby dowiedzieć się więcej o koncepcji.
Strona [adnotacje](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/annotations/)
jest opublikowanym przykładem strony koncepcyjnej.
### Zadanie (ang. Task)
Strony opisujące wykonywanie zadań zawierają minimum wyjaśnień, ale zwykle podają odnośniki do dokumentacji objaśniającej pojęcia i szerszy kontekst danego tematu.
Aby napisać nową stronę zadania, utwórz plik Markdown w podkatalogu katalogu `/content/en/docs/tasks`, z następującymi sekcjami:
| Sekcja strony |
| --- |
| overview - przegląd |
| prerequisites - wymagania wstępne |
| steps - kroki |
| discussion - dyskusja |
| whatsnext - co dalej |
Sekcje `overview`, `steps` i `discussion` pojawiają się jako komentarze na stronie zadania. Możesz dodać sekcje `prerequisites` i `whatsnext` do swojej strony za pomocą kodu `heading`.
Każdą sekcję uzupełnij treścią. Użyj następujących wytycznych:
* Użyj nagłówków poziomu H2 lub niższego (z dwoma wiodącymi znakami `#`). Sekcje są automatycznie tytułowane przez szablon.
* Dla `overview` użyj akapitu, aby ustawić kontekst dla całego tematu.
* Dla `prerequisites` używaj list punktowanych, kiedy to możliwe. Zaczynaj dodawać dodatkowe wymagania wstępne poniżej `include`. Domyślne wymagania wstępne obejmują działający klaster Kubernetesa.
* Dla `steps` używaj numerowanych list.
* Do omówienia użyj standardowej treści, aby rozwinąć informacje zawarte w sekcji `steps`.
* Dla `whatsnext`, podaj listę punktowaną z maksymalnie 5 tematami, które mogą zainteresować czytelnika jako kolejne tematy do przeczytania.
Przykład opublikowanego tematu zadania to [Korzystanie z proxy HTTP do uzyskania dostępu do API Kubernetesa](https://kubernetes.io/docs/tasks/extend-kubernetes/http-proxy-access-api/)
.
### Samouczek (ang. Tutorial)
Strona samouczka pokazuje, jak osiągnąć cel, który jest bardziej złożony niż pojedyncze zadanie. Zazwyczaj strona samouczka składa się z kilku sekcji, z których każda zawiera sekwencję kroków. Na przykład samouczek może przeprowadzać użytkownika przez przykładowy kod ilustrujący określoną funkcję Kubernetesa. Samouczki mogą zawierać ogólne wyjaśnienia, ale powinny odsyłać do powiązanych tematów koncepcyjnych w celu dogłębnego omówienia zagadnienia.
Aby napisać nową stronę samouczka, utwórz plik Markdown w podkatalogu katalogu `/content/en/docs/tutorials`, z następującymi sekcjami:
| Sekcja strony |
| --- |
| overview - przegląd |
| prerequisites - wymagania wstępne |
| objectives - cele |
| lessoncontent - treść lekcji |
| cleanup - sprzątanie |
| whatsnext - co dalej |
Sekcje `overview`, `objectives` i `lessoncontent` pojawiają się jako komentarze na stronie samouczka. Możesz dodać sekcje `prerequisites`, `cleanup` i `whatsnext` do swojej strony za pomocą kodu `heading`.
Każdą sekcję uzupełnij treścią. Użyj następujących wytycznych:
* Użyj nagłówków poziomu H2 lub niższego (z dwoma wiodącymi znakami `#`). Sekcje są automatycznie tytułowane przez szablon.
* Dla `overview` użyj akapitu, aby ustawić kontekst dla całego tematu.
* W przypadku `prerequisites` używaj, jeśli to możliwe, list punktowanych. Dodaj dodatkowe wymagania wstępne poniżej tych domyślnie uwzględnionych.
* Dla `objectives`, używaj list wypunktowanych.
* Dla `lessoncontent`, użyj mieszanki list numerowanych i treści narracyjnej w zależności od potrzeb.
* W przypadku `cleanup`, użyj numerowanych list, aby opisać kroki niezbędne do posprzątania stanu klastra po zakończeniu zadania.
* Dla `whatsnext`, podaj listę punktowaną z maksymalnie 5 tematami, które mogą zainteresować czytelnika jako kolejne tematy do przeczytania.
Przykładem opublikowanego tematu samouczka jest [Uruchamianie aplikacji bezstanowej przy użyciu Deployment](https://kubernetes.io/docs/tasks/run-application/run-stateless-application-deployment/)
.
### Materiały źródłowe (ang. Reference)
Każde narzędzie Kubernetesa ma swoją stronę materiałów źródłowych (ang. reference page), gdzie można znaleźć jego opis i listę dostępnych opcji. Dokumentacja ta jest generowana przez skrypty, które automatycznie pobierają informacje z poleceń narzędzia.
Strona z odniesieniem do narzędzia ma kilka możliwych sekcji:
| Sekcja strony |
| --- |
| streszczenie |
| opcje |
| opcje z nadrzędnych poleceń |
| przykłady |
| zobacz także |
Przykłady opublikowanych stron referencyjnych narzędzi to:
* [kubeadm init](https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm-init/)
* [kube-apiserver](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/)
* [kubectl](https://kubernetes.io/docs/reference/kubectl/kubectl/)
Co dalej?
---------
* Dowiedz się więcej o [Przewodniku stylu](https://kubernetes.io/docs/contribute/style/style-guide/)
* Dowiedz się więcej o [Przewodniku treści](https://kubernetes.io/docs/contribute/style/content-guide/)
* Dowiedz się więcej o [organizacji treści](https://kubernetes.io/docs/contribute/style/content-organization/)
---
# Documentazione | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/it/docs/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/it/docs/)
.
Documentazione
==============
* 1: [Glossario](https://kubernetes.io/it/docs/_print/#pg-2b03679960950df772fb4fe7d78427b9)
* 2: [Documentazione di Kubernetes](https://kubernetes.io/it/docs/_print/#pg-e735cee7e913aa88bc0aa10594d12966)
* 2.1: [Versioni supportate della documentazione di Kubernetes](https://kubernetes.io/it/docs/_print/#pg-92dfff0ca612d0bff40171aa9df6c4ae)
* 3: [Concetti](https://kubernetes.io/it/docs/_print/#pg-dd948255948d6b59b32c471abcb62997)
* 3.1: [Overview](https://kubernetes.io/it/docs/_print/#pg-0554ac387412eaf4e6e89b2f847dacde)
* 3.1.1: [Cos'è Kubernetes?](https://kubernetes.io/it/docs/_print/#pg-45bdca6129cf540121623e903c18ba46)
* 3.1.2: [I componenti di Kubernetes](https://kubernetes.io/it/docs/_print/#pg-13b0f1dbe89228e3d76d2ac231e245f1)
* 3.1.3: [Le API di Kubernetes](https://kubernetes.io/it/docs/_print/#pg-0c745f42e623d2b70a53bc0e6db73d95)
* 3.2: [Architettura di Kubernetes](https://kubernetes.io/it/docs/_print/#pg-2bf36ccd6b3dbeafecf87c39761b07c7)
* 3.2.1: [Comunicazione Control Plane - Nodo](https://kubernetes.io/it/docs/_print/#pg-c0251def6da29b30afebfb04549f1703)
* 3.2.2: [Concetti alla base del Cloud Controller Manager](https://kubernetes.io/it/docs/_print/#pg-bc804b02614d67025b4c788f1ca87fbc)
* 3.2.3: [Controller](https://kubernetes.io/it/docs/_print/#pg-ca8819042a505291540e831283da66df)
* 3.3: [Containers](https://kubernetes.io/it/docs/_print/#pg-a5f7383c83ab9eb9cd0e3c4c020b3ae6)
* 3.3.1: [Immagini](https://kubernetes.io/it/docs/_print/#pg-16042b4652ad19e565c7263824029a43)
* 3.3.2: [Container Environment](https://kubernetes.io/it/docs/_print/#pg-643212488f778acf04bebed65ba34441)
* 3.3.3: [Container Lifecycle Hooks](https://kubernetes.io/it/docs/_print/#pg-e6941d969d81540208a3e78bc56f43bc)
* 3.4: [Configurazione](https://kubernetes.io/it/docs/_print/#pg-275bea454e1cf4c5adeca4058b5af988)
* 3.4.1: [ConfigMaps](https://kubernetes.io/it/docs/_print/#pg-6b5ccadd699df0904e8e9917c5450c4b)
* 3.5: [Amministrazione del Cluster](https://kubernetes.io/it/docs/_print/#pg-285a3785fd3d20f437c28d87ca4dadca)
* 3.5.1: [Proxy in Kubernetes](https://kubernetes.io/it/docs/_print/#pg-08e94e6a480e0d6b2de72d84a1b97617)
* 3.6: [Esempio di modello di concetto](https://kubernetes.io/it/docs/_print/#pg-4c31edff4063c7b31c556b3eb1405c65)
* 4: [Tutorials](https://kubernetes.io/it/docs/_print/#pg-68ec2370d0409cc27325be36693f9368)
* 4.1: [Hello Minikube](https://kubernetes.io/it/docs/_print/#pg-5e3051fff9e84735871d9fb5e7b93f33)
1 - Glossario
=============
2 - Documentazione di Kubernetes
================================
2.1 - Versioni supportate della documentazione di Kubernetes
============================================================
Questo sito contiene la documentazione della versione attuale di Kubernetes e delle quattro versioni precedenti di Kubernetes.
3 - Concetti
============
La sezione Concetti ti aiuta a conoscere le parti del sistema Kubernetes e le astrazioni utilizzate da Kubernetes per rappresentare il tuo cluster e ti aiuta ad ottenere una comprensione più profonda di come funziona Kubernetes.
Overview
--------
Per lavorare con Kubernetes, usi _gli oggetti API Kubernetes_ per descrivere lo _stato desiderato del tuo cluster_: quali applicazioni o altri carichi di lavoro vuoi eseguire, quali immagini del contenitore usano, numero di repliche, quali risorse di rete e disco vuoi rendere disponibile e altro ancora. Puoi impostare lo stato desiderato creando oggetti usando l'API di Kubernetes, in genere tramite l'interfaccia della riga di comando, `kubectl`. Puoi anche utilizzare direttamente l'API di Kubernetes per interagire con il cluster e impostare o modificare lo stato desiderato.
Una volta impostato lo stato desiderato, il _Kubernetes Control Plane_ funziona per fare in modo che lo stato corrente del cluster corrisponda allo stato desiderato. Per fare ciò, Kubernetes esegue automaticamente una serie di attività, come l'avvio o il riavvio dei contenitori, il ridimensionamento del numero di repliche di una determinata applicazione e altro ancora. Il piano di controllo di Kubernetes è costituito da una raccolta di processi in esecuzione sul cluster:
* Il **Kubernetes Master** è una raccolta di tre processi che vengono eseguiti su un singolo nodo nel cluster, che è designato come nodo principale. Questi processi sono: [kube-apiserver](https://kubernetes.io/docs/admin/kube-apiserver/)
, [kube-controller-manager](https://kubernetes.io/docs/admin/kube-controller-manager/)
e [kube-scheduler](https://kubernetes.io/docs/admin/kube-scheduler/)
.
* Ogni singolo nodo non principale nel cluster esegue due processi: \* **[kubelet](https://kubernetes.io/docs/admin/kubelet/)
**, che comunica con il master di Kubernetes. \* **[kube-proxy](https://kubernetes.io/docs/admin/kube-proxy/)
**, un proxy di rete che riflette i servizi di rete di Kubernetes su ciascun nodo.
Kubernetes Objects
------------------
kubernetes contiene una serie di astrazioni che rappresentano lo stato del tuo sistema: applicazioni e carichi di lavoro distribuiti in container, le loro risorse di rete e disco associate e altre informazioni su ciò che sta facendo il tuo cluster. Queste astrazioni sono rappresentate da oggetti nell'API di Kubernetes; guarda la [Panoramica degli oggetti di Kubernetes](https://kubernetes.io/docs/concepts/abstractions/overview/)
per maggiori dettagli.
Gli oggetti di base di Kubernetes includono:
* [Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod-overview/)
* [Service](https://kubernetes.io/docs/concepts/services-networking/service/)
* [Volume](https://kubernetes.io/docs/concepts/storage/volumes/)
* [Namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/)
209/5000 Inoltre, Kubernetes contiene una serie di astrazioni di livello superiore denominate Controllori. I controller si basano sugli oggetti di base e forniscono funzionalità aggiuntive e funzionalità di convenienza. Loro includono:
* [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)
* [Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
* [StatefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)
* [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)
* [Job](https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/)
Kubernetes Control Plane
------------------------
Le varie parti del Piano di controllo di Kubernetes, come i master Kubernetes e i processi di Kubelet, regolano il modo in cui Kubernetes comunica con il cluster. Il Piano di controllo mantiene un registro di tutti gli oggetti Kubernetes nel sistema e esegue cicli di controllo continui per gestire lo stato di tali oggetti. In qualsiasi momento, i loop di controllo di Control Plane risponderanno ai cambiamenti nel cluster e lavoreranno per fare in modo che lo stato effettivo di tutti gli oggetti nel sistema corrisponda allo stato desiderato che hai fornito.
Ad esempio, quando si utilizza l'API di Kubernetes per creare un oggetto di distribuzione, si fornisce un nuovo stato desiderato per il sistema. Il piano di controllo di Kubernetes registra la creazione dell'oggetto e svolge le tue istruzioni avviando le applicazioni richieste e pianificandole sui nodi del cluster, in modo che lo stato effettivo del cluster corrisponda allo stato desiderato.
### Kubernetes Master
Il master Kubernetes è responsabile della gestione dello stato desiderato per il tuo cluster. Quando interagisci con Kubernetes, ad esempio utilizzando l'interfaccia della riga di comando `kubectl`, stai comunicando con il master di Kubernetes del cluster.
> Il "master" si riferisce a una raccolta di processi che gestiscono lo stato del cluster. In genere questi processi vengono eseguiti tutti su un singolo nodo nel cluster e questo nodo viene anche definito master. Il master può anche essere replicato per disponibilità e ridondanza.
### Kubernetes Nodes
I nodi di un cluster sono le macchine (VM, server fisici, ecc.) che eseguono i flussi di lavoro delle applicazioni e del cloud. Il master Kubernetes controlla ciascun nodo; raramente interagirai direttamente con i nodi.
#### Object Metadata
* [Annotations](https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/)
Voci correlate
--------------
Se vuoi scrivere una pagina concettuale, vedi [Uso dei modelli di pagina](https://kubernetes.io/docs/home/contribute/page-templates/)
per informazioni sul tipo di pagina di concetto e il modello di concetto.
3.1 - Overview
==============
3.1.1 - Cos'è Kubernetes?
=========================
Kubernetes è una piattaforma portatile, estensibile e open-source per la gestione di carichi di lavoro e servizi containerizzati, in grado di facilitare sia la configurazione dichiarativa che l'automazione. La piattaforma vanta un grande ecosistema in rapida crescita. Servizi, supporto e strumenti sono ampiamente disponibili nel mondo Kubernetes .
Questa pagina è una panoramica generale su Kubernetes.
Kubernetes è una piattaforma portatile, estensibile e open-source per la gestione di carichi di lavoro e servizi containerizzati, in grado di facilitare sia la configurazione dichiarativa che l'automazione. La piattaforma vanta un grande ecosistema in rapida crescita. Servizi, supporto e strumenti sono ampiamente disponibili nel mondo Kubernetes .
Il nome Kubernetes deriva dal greco, significa timoniere o pilota. Google ha reso open-source il progetto Kubernetes nel 2014. Kubernetes unisce [oltre quindici anni di esperienza di Google](https://kubernetes.io/blog/2015/04/borg-predecessor-to-kubernetes/)
nella gestione di carichi di lavoro di produzione su scala mondiale con le migliori idee e pratiche della comunità.
Facciamo un piccolo salto indietro
----------------------------------
Diamo un'occhiata alla ragione per cui Kubernetes è così utile facendo un piccolo salto indietro nel tempo.

**L'era del deployment tradizionale:** All'inizio, le organizzazioni eseguivano applicazioni su server fisici. Non c'era modo di definire i limiti delle risorse per le applicazioni in un server fisico e questo ha causato non pochi problemi di allocazione delle risorse. Ad esempio, se più applicazioni vengono eseguite sullo stesso server fisico, si possono verificare casi in cui un'applicazione assorbe la maggior parte delle risorse e, di conseguenza, le altre applicazioni non hanno le prestazioni attese. Una soluzione per questo sarebbe di eseguire ogni applicazione su un server fisico diverso. Ma questa non è una soluzione ideale, dal momento che le risorse vengono sottoutilizzate, inoltre, questa pratica risulta essere costosa per le organizzazioni, le quali devono mantenere numerosi server fisici.
**L'era del deployment virtualizzato:** Come soluzione venne introdotta la virtualizzazione. Essa consente di eseguire più macchine virtuali (VM) su una singola CPU fisica. La virtualizzazione consente di isolare le applicazioni in più macchine virtuali e fornisce un livello di sicurezza superiore, dal momento che le informazioni di un'applicazione non sono liberamente accessibili da un'altra applicazione.
La virtualizzazione consente un migliore utilizzo delle risorse riducendo i costi per l'hardware, permette una migliore scalabilità, dato che un'applicazione può essere aggiunta o aggiornata facilmente, e ha molti altri vantaggi.
Ogni VM è una macchina completa che esegue tutti i componenti, compreso il proprio sistema operativo, sopra all'hardware virtualizzato.
**L'era del deployment in container:** I container sono simili alle macchine virtuali, ma presentano un modello di isolamento più leggero, condividendo il sistema operativo (OS) tra le applicazioni. Pertanto, i container sono considerati più leggeri. Analogamente a una macchina virtuale, un container dispone di una segregazione di filesystem, CPU, memoria, PID e altro ancora. Poiché sono disaccoppiati dall'infrastruttura sottostante, risultano portabili tra differenti cloud e diverse distribuzioni.
I container sono diventati popolari dal momento che offrono molteplici vantaggi, ad esempio:
* Creazione e distribuzione di applicazioni in modalità Agile: maggiore facilità ed efficienza nella creazione di immagini container rispetto all'uso di immagini VM.
* Adozione di pratiche per lo sviluppo/test/rilascio continuativo: consente la frequente creazione e la distribuzione di container image affidabili, dando la possibilità di fare rollback rapidi e semplici (grazie all'immutabilità dell'immagine stessa).
* Separazione delle fasi di Dev e Ops: le container image vengono prodotte al momento della compilazione dell'applicativo piuttosto che nel momento del rilascio, permettendo così di disaccoppiare le applicazioni dall'infrastruttura sottostante.
* L'osservabilità non riguarda solo le informazioni e le metriche del sistema operativo, ma anche lo stato di salute e altri segnali dalle applicazioni.
* Coerenza di ambiente tra sviluppo, test e produzione: i container funzionano allo stesso modo su un computer portatile come nel cloud.
* Portabilità tra cloud e sistemi operativi differenti: lo stesso container funziona su Ubuntu, RHEL, CoreOS, on-premise, nei più grandi cloud pubblici e da qualsiasi altra parte.
* Gestione incentrata sulle applicazioni: Aumenta il livello di astrazione dall'esecuzione di un sistema operativo su hardware virtualizzato all'esecuzione di un'applicazione su un sistema operativo utilizzando risorse logiche.
* Microservizi liberamente combinabili, distribuiti, ad alta scalabilità: le applicazioni sono suddivise in pezzi più piccoli e indipendenti che possono essere distribuite e gestite dinamicamente - niente stack monolitici che girano su una singola grande macchina.
* Isolamento delle risorse: le prestazioni delle applicazioni sono prevedibili.
* Utilizzo delle risorse: alta efficienza e densità.
Perché necessito di Kubernetes e cosa posso farci
-------------------------------------------------
I container sono un buon modo per distribuire ed eseguire le tue applicazioni. In un ambiente di produzione, è necessario gestire i container che eseguono le applicazioni e garantire che non si verifichino interruzioni dei servizi. Per esempio, se un container si interrompe, è necessario avviare un nuovo container. Non sarebbe più facile se questo comportamento fosse gestito direttamente da un sistema?
È proprio qui che Kubernetes viene in soccorso! Kubernetes ti fornisce un framework per far funzionare i sistemi distribuiti in modo resiliente. Kubernetes si occupa della scalabilità, failover, distribuzione delle tue applicazioni. Per esempio, Kubernetes può facilmente gestire i rilasci con modalità Canary deployment.
Kubernetes ti fornisce:
* **Scoperta dei servizi e bilanciamento del carico** Kubernetes può esporre un container usando un nome DNS o il suo indirizzo IP. Se il traffico verso un container è alto, Kubernetes è in grado di distribuire il traffico su più container in modo che il servizio rimanga stabile.
* **Orchestrazione dello storage** Kubernetes ti permette di montare automaticamente un sistema di archiviazione di vostra scelta, come per esempio storage locale, dischi forniti da cloud pubblici, e altro ancora.
* **Rollout e rollback automatizzati** Puoi utilizzare Kubernetes per descrivere lo stato desiderato per i propri container, e Kubernetes si occuperà di cambiare lo stato attuale per raggiungere quello desiderato ad una velocità controllata. Per esempio, puoi automatizzare Kubernetes per creare nuovi container per il tuo servizio, rimuovere i container esistenti e adattare le loro risorse a quelle richieste dal nuovo container.
* **Ottimizzazione dei carichi** Fornisci a Kubernetes un cluster di nodi per eseguire i container. Puoi istruire Kubernetes su quanta CPU e memoria (RAM) ha bisogno ogni singolo container. Kubernetes allocherà i container sui nodi per massimizzare l'uso delle risorse a disposizione.
* **Self-healing** Kubernetes riavvia i container che si bloccano, sostituisce container, termina i container che non rispondono agli health checks, e evita di far arrivare traffico ai container che non sono ancora pronti per rispondere correttamente.
* **Gestione di informazioni sensibili e della configurazione** Kubernetes consente di memorizzare e gestire informazioni sensibili, come le password, i token OAuth e le chiavi SSH. Puoi distribuire e aggiornare le informazioni sensibili e la configurazione dell'applicazione senza dover ricostruire le immagini dei container e senza svelare le informazioni sensibili nella configurazione del tuo sistema.
Cosa non è Kubernetes
---------------------
Kubernetes non è un sistema PaaS (Platform as a Service) tradizionale e completo. Dal momento che Kubernetes opera a livello di container piuttosto che che a livello hardware, esso fornisce alcune caratteristiche generalmente disponibili nelle offerte PaaS, come la distribuzione, il ridimensionamento, il bilanciamento del carico, la registrazione e il monitoraggio. Tuttavia, Kubernetes non è monolitico, e queste soluzioni predefinite sono opzionali ed estensibili. Kubernetes fornisce gli elementi base per la costruzione di piattaforme di sviluppo, ma conserva le scelte dell'utente e la flessibilità dove è importante.
Kubernetes:
* Non limita i tipi di applicazioni supportate. Kubernetes mira a supportare una grande varietà di carichi di lavoro, compresi i carichi di lavoro stateless, stateful e elaborazione di dati. Se un'applicazione può essere eseguita in un container, dovrebbe funzionare alla grande anche su Kubernetes.
* Non compila il codice sorgente e non crea i container. I flussi di Continuous Integration, Delivery, and Deployment (CI/CD) sono determinati dalla cultura e dalle preferenze dell'organizzazione e dai requisiti tecnici.
* Non fornisce servizi a livello applicativo, come middleware (per esempio, bus di messaggi), framework di elaborazione dati (per esempio, Spark), database (per esempio, mysql), cache, né sistemi di storage distribuito (per esempio, Ceph) come servizi integrati. Tali componenti possono essere eseguiti su Kubernetes, e/o possono essere richiamati da applicazioni che girano su Kubernetes attraverso meccanismi come l'[Open Service Broker](https://openservicebrokerapi.org/)
.
* Non impone soluzioni di logging, monitoraggio o di gestione degli alert. Fornisce alcune integrazioni come dimostrazione, e meccanismi per raccogliere ed esportare le metriche.
* Non fornisce né rende obbligatorio un linguaggio/sistema di configurazione (per esempio, Jsonnet). Fornisce un'API dichiarativa che può essere richiamata da qualsiasi sistema.
* Non fornisce né adotta alcun sistema di gestione completa della macchina, configurazione, manutenzione, gestione o sistemi di self healing.
* Inoltre, Kubernetes non è un semplice sistema di orchestrazione. Infatti, questo sistema elimina la necessità di orchestrazione. La definizione tecnica di orchestrazione è l'esecuzione di un flusso di lavoro definito: prima si fa A, poi B, poi C. Al contrario, Kubernetes è composto da un insieme di processi di controllo indipendenti e componibili che guidano costantemente lo stato attuale verso lo stato desiderato. Non dovrebbe importare come si passa dalla A alla C. Anche il controllo centralizzato non è richiesto. Questo si traduce in un sistema più facile da usare, più potente, robusto, resiliente ed estensibile.
Voci correlate
--------------
* Dai un'occhiata alla pagina [i componenti di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/components/)
* Sai già [Come Iniziare](https://kubernetes.io/docs/setup/)
?
3.1.2 - I componenti di Kubernetes
==================================
Un cluster di Kubernetes è costituito da un insieme di componenti che sono, come minimo, un Control Plane e uno o più sistemi di elaborazione, detti nodi.
Facendo il deployment di Kubernetes, ottieni un cluster.
Un cluster Kubernetes è un'insieme di macchine, chiamate nodi, che eseguono container gestiti da Kubernetes. Un cluster ha almeno un Worker Node.
Il/I Worker Node ospitano i Pod che eseguono i workload dell'utente. Il/I Control Plane Node gestiscono i Worker Node e tutto quanto accade all'interno del cluster. Per garantire la high-availability e la possibilità di failover del cluster, vengono utilizzati più Control Plane Node.
Questo documento descrive i diversi componenti che sono necessari per avere un cluster Kubernetes completo e funzionante.
Questo è un diagramma di un cluster Kubernetes con tutti i componenti e le loro relazioni.

Componenti della Control Plane
------------------------------
I componenti del Control Plane sono responsabili di tutte le decisioni globali sul cluster (ad esempio, lo scheduling) oltre che a rilevare e rispondere agli eventi del cluster (ad esempio, l'avvio di un nuovo [pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
quando il valore `replicas` di un deployment non è soddisfatto).
I componenti della Control Plane possono essere eseguiti su qualsiasi nodo del cluster stesso. Solitamente, per semplicità, gli script di installazione tendono a eseguire tutti i componenti della Control Plane sulla stessa macchina, separando la Control Plane dai workload dell'utente. Vedi [creare un cluster in High-Availability](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/)
per un esempio di un'installazione multi-master.
### kube-apiserver
L'API server è un componente di Kubernetes [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
che espone le Kubernetes API. L'API server è il front end del control plane di Kubernetes.
La principale implementazione di un server Kubernetes API è [kube-apiserver](https://kubernetes.io/docs/reference/generated/kube-apiserver/)
. kube-apiserver è progettato per scalare orizzontalmente, cioè scala aumentando il numero di istanze. Puoi eseguire multiple istanze di kube-apiserver e bilanciare il traffico tra queste istanze.
### etcd
È un database key-value ridondato, che è usato da Kubernetes per salvare tutte le informazioni del cluster.
Se il tuo cluster utilizza etcd per salvare le informazioni, assicurati di avere una strategia di [backup](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/#backing-up-an-etcd-cluster)
per questi dati.
Puoi trovare informazioni dettagliate su etcd sulla [documentazione](https://etcd.io/docs/)
ufficiale.
### kube-scheduler
Componente della Control Plane che controlla i pod appena creati che non hanno un nodo assegnato, e dopo averlo identificato glielo assegna.
I fattori presi in considerazioni nell'individuare un nodo a cui assegnare l'esecuzione di un Pod includono la richiesta di risorse del Pod stesso e degli altri workload presenti nel sistema, i vincoli delle hardware/software/policy, le indicazioni di affinity e di anti-affinity, requisiti relativi alla disponibilità di dati/Volumes, le interferenze tra diversi workload e le scadenze.
### kube-controller-manager
Componente della Control Plane che gestisce [controllers](https://kubernetes.io/it/docs/concepts/architecture/controller/ "Un software che implementa un circuito di controllo che osserva lo stato condiviso del cluster attraverso l'API server e apporta le modifiche necessarie per portate lo stato corrente verso lo stato desiderato.")
.
Da un punto di vista logico, ogni [controller](https://kubernetes.io/it/docs/concepts/architecture/controller/ "Un software che implementa un circuito di controllo che osserva lo stato condiviso del cluster attraverso l'API server e apporta le modifiche necessarie per portate lo stato corrente verso lo stato desiderato.")
è un processo separato, ma per ridurre la complessità, tutti i principali controller di Kubernetes vengono raggruppati in un unico container ed eseguiti in un singolo processo.
Alcuni esempi di controller gestiti dal kube-controller-manager sono:
* Node Controller: Responsabile del monitoraggio dei nodi del cluster, e.g. della gestione delle azioni da eseguire quando un nodo diventa non disponibile.
* Replication Controller: Responsabile per il mantenimento del corretto numero di Pod per ogni ReplicaSet presente nel sistema
* Endpoints Controller: Popola gli oggetti Endpoints (cioè, mette in relazioni i Pods con i Services).
* Service Account & Token Controllers: Creano gli account di default e i token di accesso alle API per i nuovi namespaces.
### cloud-controller-manager
Un componente della [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
di Kubernetes che aggiunge logiche di controllo specifiche per il cloud. Il cloud-controller-manager ti permette di collegare il tuo cluster con le API del cloud provider e separa le componenti che interagiscono con la piattaforma cloud dai componenti che interagiscono solamente col cluster.
Il cloud-controller-manager esegue dei controller specifici del tuo cloud provider. Se hai una installazione Kubernetes on premises, o un ambiente di laboratorio nel tuo PC, il cluster non ha un cloud-controller-manager.
Come nel kube-controller-manager, il cloud-controller-manager combina diversi control loop logicamente indipendenti in un singolo binario che puoi eseguire come un singolo processo. Tu puoi scalare orizzontalmente (eseguire più di una copia) per migliorare la responsività o per migliorare la tolleranza ai fallimenti.
I seguenti controller hanno dipendenze verso implementazioni di specifici cloud provider:
* Node Controller: Per controllare se sul cloud provider i nodi che hanno smesso di rispondere sono stati cancellati
* Route Controller: Per configurare le network route nella sottostante infrastruttura cloud
* Service Controller: Per creare, aggiornare ed eliminare i load balancer del cloud provider
Componenti dei Nodi
-------------------
I componenti del nodo vengono eseguiti su ogni nodo, mantenendo i pod in esecuzione e fornendo l'ambiente di runtime Kubernetes.
### kubelet
Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.
La kubelet riceve un set di PodSpecs che vengono forniti attraverso vari meccanismi, e si assicura che i container descritti in questi PodSpecs funzionino correttamente e siano sani. La kubelet non gestisce i container che non sono stati creati da Kubernetes.
### kube-proxy
[kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/)
è un proxy eseguito su ogni nodo del cluster, responsabile della gestione dei Kubernetes [Service](https://kubernetes.io/it/docs/concepts/services-networking/service/ "A way to expose an application running on a set of Pods as a network service.")
.
I kube-proxy mantengono le regole di networking sui nodi. Queste regole permettono la comunicazione verso gli altri nodi del cluster o l'esterno.
Il kube-proxy usa le librerie del sistema operativo quando possible; in caso contrario il kube-proxy gestisce il traffico direttamente.
### Container Runtime
Il container runtime è il software che è responsabile per l'esecuzione dei container.
Kubernetes supporta diversi container runtimes: [Docker](http://www.docker.com/)
, [containerd](https://containerd.io/)
, [cri-o](https://cri-o.io/)
, [rktlet](https://github.com/kubernetes-incubator/rktlet)
e tutte le implementazioni di [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Addons
------
Gli Addons usano le risorse Kubernetes ([DaemonSet](https://kubernetes.io/it/docs/concepts/workloads/controllers/daemonset "Assicura che una copia di un Pod è attiva su tutti nodi di un cluster.")
, [Deployment](https://kubernetes.io/it/docs/concepts/workloads/controllers/deployment/ "Gestisce una applicazione replicata nel tuo cluster.")
, etc) per implementare funzionalità di cluster. Dal momento che gli addons forniscono funzionalità a livello di cluster, le risorse che necessitano di un namespace, vengono collocate nel namespace `kube-system`.
Alcuni addons sono descritti di seguito; mentre per una più estesa lista di addons, per favore vedere [Addons](https://kubernetes.io/docs/concepts/cluster-administration/addons/)
.
### DNS
Mentre gli altri addons non sono strettamente richiesti, tutti i cluster Kubernetes dovrebbero essere muniti di un [DNS del cluster](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)
, dal momento che molte applicazioni lo necessitano.
Il DNS del cluster è un server DNS aggiuntivo rispetto ad altri server DNS presenti nella rete, e si occupa specificatamente dei record DNS per i servizi Kubernetes.
I container eseguiti da Kubernetes automaticamente usano questo server per la risoluzione DNS.
### Interfaccia web (Dashboard)
La [Dashboard](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)
è una interfaccia web per i cluster Kubernetes. Permette agli utenti di gestire e fare troubleshooting delle applicazioni che girano nel cluster, e del cluster stesso.
### Monitoraggio dei Container
Il [Monitoraggio dei Container](https://kubernetes.io/docs/tasks/debug-application-cluster/resource-usage-monitoring/)
salva serie temporali di metriche generiche dei container in un database centrale e fornisce una interfaccia in cui navigare i dati stessi.
### Log a livello di Cluster
Un [log a livello di cluster](https://kubernetes.io/docs/concepts/cluster-administration/logging/)
è responsabile per il salvataggio dei log dei container in un log centralizzato la cui interfaccia permette di cercare e navigare nei log.
Voci correlate
--------------
* Scopri i concetti relativi ai [Nodi](https://kubernetes.io/docs/concepts/architecture/nodes/)
* Scopri i concetti relativi ai [Controller](https://kubernetes.io/it/docs/concepts/architecture/controller/)
* Scopri i concetti relativi al [kube-scheduler](https://kubernetes.io/docs/concepts/scheduling/kube-scheduler/)
* Leggi la [documentazione](https://etcd.io/docs/)
ufficiale di etcd
3.1.3 - Le API di Kubernetes
============================
Le API di Kubernetes ti permettono di interrogare e manipolare lo stato degli oggetti in Kubernetes. Il cuore del Control Plane di Kubernetes è l'API server e le API HTTP che esso espone. Ogni entità o componente che si interfaccia con il cluster (gli utenti, le singole parti del tuo cluster, i componenti esterni), comunica attraverso l'API server.
Le convenzioni generali seguite dalle API sono descritte in [API conventions doc](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md)
.
Gli _endpoints_ delle API, la lista delle risorse esposte ed i relativi esempi sono descritti in [API Reference](https://kubernetes.io/docs/reference)
.
L'accesso alle API da remoto è discusso in [Controllare l'accesso alle API](https://kubernetes.io/docs/reference/access-authn-authz/controlling-access/)
.
Le API di Kubernetes servono anche come riferimento per lo schema dichiarativo della configurazione del sistema stesso. Il comando [kubectl](https://kubernetes.io/docs/reference/kubectl/overview/)
può essere usato per creare, aggiornare, cancellare ed ottenere le istanze delle risorse esposte attraverso le API.
Kubernetes assicura la persistenza del suo stato (al momento in [etcd](https://coreos.com/docs/distributed-configuration/getting-started-with-etcd/)
) usando la rappresentazione delle risorse implementata dalle API.
Kubernetes stesso è diviso in differenti componenti, i quali interagiscono tra loro attraverso le stesse API.
Evoluzione delle API
--------------------
In base alla nostra esperienza, ogni sistema di successo ha bisogno di evolvere ovvero deve estendersi aggiungendo funzionalità o modificare le esistenti per adattarle a nuovi casi d'uso. Le API di Kubernetes sono quindi destinate a cambiare e ad estendersi. In generale, ci si deve aspettare che nuove risorse vengano aggiunte di frequente cosi come nuovi campi possano altresì essere aggiunti a risorse esistenti. L'eliminazione di risorse o di campi devono seguire la [politica di deprecazione delle API](https://kubernetes.io/docs/reference/using-api/deprecation-policy/)
.
In cosa consiste una modifica compatibile e come modificare le API è descritto dal [API change document](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md)
.
Definizioni OpenAPI e Swagger
-----------------------------
La documentazione completa e dettagliata delle API è fornita attraverso la specifica [OpenAPI](https://www.openapis.org/)
.
Dalla versione 1.10 di Kubernetes, l'API server di Kubernetes espone le specifiche OpenAPI attraverso il seguente _endpoint_ `/openapi/v2`. Attraverso i seguenti _headers_ HTTP è possibile richiedere un formato specifico:
| Header | Possibili Valori |
| --- | --- |
| Accept | `application/json`, `application/com.github.proto-openapi.spec.v2@v1.0+protobuf` (il content-type di default è `application/json` per `*/*` ovvero questo header può anche essere omesso) |
| Accept-Encoding | `gzip` (questo header è facoltativo) |
Prima della versione 1.14, gli _endpoints_ che includono il formato del nome all'interno del segmento (`/swagger.json`, `/swagger-2.0.0.json`, `/swagger-2.0.0.pb-v1`, `/swagger-2.0.0.pb-v1.gz`) espongo le specifiche OpenAPI in formati differenti. Questi _endpoints_ sono deprecati, e saranno rimossi dalla versione 1.14 di Kubernetes.
**Esempi per ottenere le specifiche OpenAPI**:
| Prima della 1.10 | Dalla versione 1.10 di Kubernetes |
| --- | --- |
| GET /swagger.json | GET /openapi/v2 **Accept**: application/json |
| GET /swagger-2.0.0.pb-v1 | GET /openapi/v2 **Accept**: [application/com.github.proto-openapi.spec.v2@v1.0](mailto:application/com.github.proto-openapi.spec.v2@v1.0) +protobuf |
| GET /swagger-2.0.0.pb-v1.gz | GET /openapi/v2 **Accept**: [application/com.github.proto-openapi.spec.v2@v1.0](mailto:application/com.github.proto-openapi.spec.v2@v1.0) +protobuf **Accept-Encoding**: gzip |
Kubernetes implementa per le sue API anche una serializzazione alternativa basata sul formato Protobuf che è stato pensato principalmente per la comunicazione intra-cluster, documentato nella seguente [design proposal](https://github.com/kubernetes/community/blob/master/contributors/design-proposals/api-machinery/protobuf.md)
, e i files IDL per ciascun schema si trovano nei _Go packages_ che definisco i tipi delle API.
Prima della versione 1.14, l'_apiserver_ di Kubernetes espone anche un'_endpoint_, `/swaggerapi`, che può essere usato per ottenere le documentazione per le API di Kubernetes secondo le specifiche [Swagger v1.2](http://swagger.io/)
. Questo _endpoint_ è deprecato, ed è stato rimosso nella versione 1.14 di Kubernetes.
Versionamento delle API
-----------------------
Per facilitare l'eliminazione di campi specifici o la modifica della rappresentazione di una data risorsa, Kubernetes supporta molteplici versioni della stessa API disponibili attraverso differenti indirizzi, come ad esempio `/api/v1` oppure `/apis/extensions/v1beta1`.
Abbiamo deciso di versionare a livello di API piuttosto che a livello di risorsa o di campo per assicurare che una data API rappresenti una chiara, consistente vista delle risorse di sistema e dei sui comportamenti, e per abilitare un controllo degli accessi sia per le API in via di decommissionamento che per quelle sperimentali.
Si noti che il versionamento delle API ed il versionamento del Software sono indirettamente collegati. La [API and release versioning proposal](https://git.k8s.io/community/contributors/design-proposals/release/versioning.md)
descrive la relazione tra le versioni delle API ed le versioni del Software.
Differenti versioni delle API implicano differenti livelli di stabilità e supporto. I criteri per ciascuno livello sono descritti in dettaglio nella [API Changes documentation](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md#alpha-beta-and-stable-versions)
. Queste modifiche sono qui ricapitolate:
* Livello alpha:
* Il nome di versione contiene `alpha` (e.g. `v1alpha1`).
* Potrebbe contenere dei _bug_. Abilitare questa funzionalità potrebbe esporre al rischio di _bugs_. Disabilitata di default.
* Il supporto di questa funzionalità potrebbe essere rimosso in ogni momento senza previa notifica.
* Questa API potrebbe cambiare in modo incompatibile in rilasci futuri del Software e senza previa notifica.
* Se ne raccomandata l'utilizzo solo in _clusters_ di test creati per un breve periodo di vita, a causa di potenziali _bugs_ e delle mancanza di un supporto di lungo periodo.
* Livello beta:
* Il nome di versione contiene `beta` (e.g. `v2beta3`).
* Il codice è propriamente testato. Abilitare la funzionalità è considerato sicuro. Abilitata di default.
* Il supporto per la funzionalità nel suo complesso non sarà rimosso, tuttavia potrebbe subire delle modifiche.
* Lo schema e/o la semantica delle risorse potrebbe cambiare in modo incompatibile in successivi rilasci beta o stabili. Nel caso questo dovesse verificarsi, verrano fornite istruzioni per la migrazione alla versione successiva. Questo potrebbe richiedere la cancellazione, modifica, e la ri-creazione degli oggetti supportati da questa API. Questo processo di modifica potrebbe richiedere delle valutazioni. La modifica potrebbe richiedere un periodo di non disponibilità dell'applicazione che utilizza questa funzionalità.
* Raccomandata solo per applicazioni non critiche per la vostra impresa a causa dei potenziali cambiamenti incompatibili in rilasci successivi. Se avete più _clusters_ che possono essere aggiornati separatamente, potreste essere in grado di gestire meglio questa limitazione.
* **Per favore utilizzate le nostre versioni beta e forniteci riscontri relativamente ad esse! Una volta promosse a stabili, potrebbe non essere semplice apportare cambiamenti successivi.**
* Livello stabile:
* Il nome di versione è `vX` dove `X` è un intero.
* Le funzionalità relative alle versioni stabili continueranno ad essere presenti per parecchie versioni successive.
API groups
----------
Per facilitare l'estendibilità delle API di Kubernetes, sono stati implementati gli [_API groups_](https://git.k8s.io/community/contributors/design-proposals/api-machinery/api-group.md)
.
L'_API group_ è specificato nel percorso REST ed anche nel campo `apiVersion` di un oggetto serializzato.
Al momento ci sono diversi _API groups_ in uso:
1. Il gruppo _core_, spesso referenziato come il _legacy group_, è disponibile al percorso REST `/api/v1` ed utilizza `apiVersion: v1`.
2. I gruppi basati su un nome specifico sono disponibili attraverso il percorso REST `/apis/$GROUP_NAME/$VERSION`, ed usano `apiVersion: $GROUP_NAME/$VERSION` (e.g. `apiVersion: batch/v1`). La lista completa degli _API groups_ supportati e' descritta nel documento [Kubernetes API reference](https://kubernetes.io/docs/reference/)
.
Vi sono due modi per supportati per estendere le API attraverso le [_custom resources_](https://kubernetes.io/docs/concepts/api-extension/custom-resources/)
:
1. [CustomResourceDefinition](https://kubernetes.io/docs/tasks/access-kubernetes-api/extend-api-custom-resource-definitions/)
è pensato per utenti con esigenze CRUD basilari.
2. Utenti che necessitano di un nuovo completo set di API che utilizzi appieno la semantica di Kubernetes possono implementare il loro _apiserver_ ed utilizzare l'[_aggregator_](https://kubernetes.io/docs/tasks/access-kubernetes-api/configure-aggregation-layer/)
per fornire ai propri utilizzatori la stessa esperienza a cui sono abituati con le API incluse nativamente in Kubernetes.
Abilitare o disabilitare gli _API groups_
-----------------------------------------
Alcune risorse ed _API groups_ sono abilitati di default. Questi posso essere abilitati o disabilitati attraverso il settaggio/flag `--runtime-config` applicato sull'_apiserver_. `--runtime-config` accetta valori separati da virgola. Per esempio: per disabilitare `batch/v1`, usa la seguente configurazione `--runtime-config=batch/v1=false`, per abilitare `batch/v2alpha1`, utilizzate `--runtime-config=batch/v2alpha1`.
Il _flag_ accetta set di coppie _chiave/valore_ separati da virgola che descrivono la configurazione a _runtime_ dell'_apiserver_.
#### Nota:
Abilitare o disabilitare risorse o gruppi richiede il riavvio dell'_apiserver_ e del _controller-manager_ affinché le modifiche specificate attraverso il flag `--runtime-config` abbiano effetto.
Abilitare specifiche risorse nel gruppo extensions/v1beta1
----------------------------------------------------------
DaemonSets, Deployments, StatefulSet, NetworkPolicies, PodSecurityPolicies e ReplicaSets presenti nel gruppo di API `extensions/v1beta1` sono disabilitate di default. Per esempio: per abilitare deployments and daemonsets, utilizza la seguente configurazione `--runtime-config=extensions/v1beta1/deployments=true,extensions/v1beta1/daemonsets=true`.
#### Nota:
Abilitare/disabilitare una singola risorsa è supportato solo per il gruppo di API `extensions/v1beta1` per ragioni storiche.
3.2 - Architettura di Kubernetes
================================
3.2.1 - Comunicazione Control Plane - Nodo
==========================================
Questo documento cataloga le connessioni tra il piano di controllo (_control-plane_), in realtà l'apiserver, e il cluster Kubernetes. L'intento è di consentire agli utenti di personalizzare la loro installazione per rafforzare la configurazione di rete affinché il cluster possa essere eseguito su una rete pubblica (o su IP completamente pubblici resi disponibili da un fornitore di servizi cloud).
Dal Nodo al control-plane
-------------------------
Kubernetes adotta un pattern per le API di tipo _"hub-and-spoke"_. Tutte le chiamate delle API eseguite sui vari nodi sono effettuate verso l'apiserver (nessuno degli altri componenti principali è progettato per esporre servizi remoti). L'apiserver è configurato per l'ascolto di connessioni remote su una porta HTTPS protetta (443) con una o più forme di [autenticazioni client](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)
abilitate. Si dovrebbero abilitare una o più forme di [autorizzazioni](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)
, in particolare nel caso in cui siano ammesse [richieste anonime](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#anonymous-requests)
o [_token_ legati ad un account di servizio (_service account_)](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#service-account-tokens)
.
Il certificato pubblico (_public root certificate_) relativo al cluster corrente deve essere fornito ai vari nodi di modo che questi possano connettersi in modo sicuro all'apiserver insieme alle credenziali valide per uno specifico _client_. Ad esempio, nella configurazione predefinita di un cluster [GKE](https://cloud.google.com/kubernetes-engine?hl=it)
, le credenziali del client fornite al kubelet hanno la forma di un certificato client. Si veda [inizializzazione TLS del kubelet TLS](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet-tls-bootstrapping/)
per la fornitura automatica dei certificati client al _kubelet_.
I Pod che desiderano connettersi all'apiserver possono farlo in modo sicuro sfruttando un account di servizio in modo che Kubernetes inserisca automaticamente il certificato pubblico di radice e un token valido al portatore (_bearer token_) all'interno Pod quando questo viene istanziato. In tutti i namespace è configurato un _Service_ con nome `kubernetes` con un indirizzo IP virtuale che viene reindirizzato (tramite _kube-proxy_) all'endpoint HTTPS dell'apiserver.
Anche i componenti del piano d controllo comunicano con l'apiserver del cluster su di una porta sicura esposta da quest'ultimo.
Di conseguenza, la modalità operativa predefinita per le connessioni dai nodi e dai Pod in esecuzione sui nodi verso il _control-plane_ è protetta da un'impostazione predefinita e può essere eseguita su reti non sicure e/o pubbliche.
Dal control-plane al nodo
-------------------------
Esistono due percorsi di comunicazione principali dal _control-plane_ (apiserver) verso i nodi. Il primo è dall'apiserver verso il processo _kubelet_ in esecuzione su ogni nodo nel cluster. Il secondo è dall'apiserver a ciascun nodo, Pod, o servizio attraverso la funzionalità proxy dell'apiserver.
### Dall'apiserver al _kubelet_
Le connessioni dall'apiserver al _kubelet_ vengono utilizzate per:
* Prendere i log relativi ai vari Pod.
* Collegarsi (attraverso kubectl) ai Pod in esecuzione.
* Fornire la funzionalità di _port-forwarding_ per i _kubelet_.
Queste connessioni terminano all'endpoint HTTPS del _kubelet_. Di default, l'apiserver non verifica il certificato servito dal _kubelet_, il che rende la connessione soggetta ad attacchi _man-in-the-middle_, e tale da essere considerato **non sicuro (unsafe)** se eseguito su reti non protette e/o pubbliche.
Per verificare questa connessione, si utilizzi il parametro `--kubelet-certificate-authority` al fine di fornire all'apiserver un insieme di certificati radice da utilizzare per verificare il il certificato servito dal _kubelet_.
Se questo non è possibile, si usi un [tunnel SSH](https://kubernetes.io/docs/tasks/access-application-cluster/port-forward-access-application-cluster/)
tra l'apiserver e il _kubelet_, se richiesto, per evitare il collegamento su una rete non protetta o pubblica.
In fine, l'[autenticazione e/o l'autorizzazione del kubelet](https://kubernetes.io/docs/admin/kubelet-authentication-authorization/)
dovrebbe essere abilitate per proteggere le API esposte dal _kubelet_.
### Dall'apiserver ai nodi, Pod, e servizi
Le connessioni dall'apiserver verso un nodo, Pod o servizio avvengono in modalità predefinita su semplice connessione HTTP e quindi non sono né autenticate né criptata. Queste connessioni possono essere eseguite su una connessione HTTPS sicura mediante il prefisso `https:` al nodo, Pod o nome del servizio nell'URL dell'API, ma non valideranno il certificato fornito dall'endpoint HTTPS né forniranno le credenziali del client così anche se la connessione verrà criptata, non fornirà alcuna garanzia di integrità. **Non è attualmente sicuro** eseguire queste connessioni su reti non protette e/o pubbliche.
### I tunnel SSH
Kubernetes supporta i _tunnel_ SSH per proteggere la comunicazione tra il _control-plane_ e i nodi. In questa configurazione, l'apiserver inizializza un tunnel SSH con ciascun nodo del cluster (collegandosi al server SSH in ascolto sulla porta 22) e fa passare tutto il traffico verso il _kubelet_, il nodo, il Pod, o il servizio attraverso questo tunnel. Questo tunnel assicura che il traffico non sia esposto al di fuori della rete su cui sono in esecuzioni i vari nodi.
I tunnel SSH sono al momento deprecati ovvero non dovrebbero essere utilizzati a meno che ci siano delle esigenze particolari. Il servizio `Konnectivity` è pensato per rimpiazzare questo canale di comunicazione.
### Il servizio _Konnectivity_
FEATURE STATE: `Kubernetes v1.18 [beta]`
Come rimpiazzo dei tunnel SSH, il servizio _Konnectivity_ fornisce un proxy a livello TCP per la comunicazione tra il _control-plane_ e il cluster. Il servizio _Konnectivity_ consiste in due parti: il _Konnectivity_ server e gli agenti _Konnectivity_, in esecuzione rispettivamente sul _control-plane_ e sui vari nodi. Gli agenti _Konnectivity_ inizializzano le connessioni verso il server _Konnectivity_ e mantengono le connessioni di rete. Una volta abilitato il servizio _Konnectivity_, tutto il traffico tra il _control-plane_ e i nodi passa attraverso queste connessioni.
Si può fare riferimento al [tutorial per il servizio _Konnectivity_](https://kubernetes.io/docs/tasks/extend-kubernetes/setup-konnectivity/)
per configurare il servizio _Konnectivity_ all'interno del cluster
3.2.2 - Concetti alla base del Cloud Controller Manager
=======================================================
Il concetto di CCM (cloud controller manager), da non confondere con il binario, è stato originariamente creato per consentire di sviluppare Kubernetes indipendentemente dall'implementazione dello specifico cloud provider. Il cloud controller manager viene eseguito insieme ad altri componenti principali come il Kubernetes controller manager, il server API e lo scheduler. Può anche essere avviato come addon di Kubernetes, nel qual caso viene eseguito su Kubernetes.
Il design del cloud controller manager è basato su un meccanismo di plug-in che consente ai nuovi provider cloud di integrarsi facilmente con Kubernetes creando un plug-in. Sono in atto programmi per l'aggiunta di nuovi provider di cloud su Kubernetes e per la migrazione dei provider che usano il vecchio metodo a questo nuovo metodo.
Questo documento discute i concetti alla base del cloud controller manager e fornisce dettagli sulle funzioni associate.
Ecco l'architettura di un cluster Kubernetes senza il gestore del controller cloud:

Architettura
------------
Nel diagramma precedente, Kubernetes e il provider cloud sono integrati attraverso diversi componenti:
* Kubelet
* Kubernetes controller manager
* Kubernetes API server
Il CCM consolida tutta la logica dipendente dal cloud presente nei tre componenti precedenti, per creare un singolo punto di integrazione con il cloud. La nuova architettura con il CCM si presenta così:

Componenti del CCM
------------------
Il CCM divide alcune funzionalità del Kubernetes controller manager (KCM) e le esegue in un differente processo. In particolare, toglie dal KCM le integrazioni con il cloud specifico. Il KCM ha i seguenti controller che dipendono dal cloud specifico:
* Node controller
* Volume controller
* Route controller
* Service controller
Nella versione 1.9, il CCM esegue i seguenti controller dall'elenco precedente:
* Node controller
* Route controller
* Service controller
#### Nota:
È stato deliberatamente deciso di non spostare il Volume controller nel CCM. Data la complessità del Volume controller e gli sforzi già fatti per astrarre le logiche specifiche dei singoli fornitori, è stato deciso che il Volume controller non verrà spostato nel CCM.
Il piano originale per supportare i volumi utilizzando il CCM era di utilizzare [Flex](https://kubernetes.io/docs/concepts/storage/volumes/#flexVolume)
per supportare volumi collegabili. Tuttavia, una implementazione parallela, nota come [CSI](https://kubernetes.io/docs/concepts/storage/volumes/#csi)
è stata designata per sostituire Flex.
Considerando queste evoluzioni, abbiamo deciso di adottare un approccio intermedio finché il CSI non è pronto.
Funzioni del CCM
----------------
Il CCM eredita le sue funzioni da componenti di Kubernetes che dipendono da uno specifico provider di cloud. Questa sezione è strutturata sulla base di tali componenti.
### 1\. Kubernetes controller manager
La maggior parte delle funzioni del CCM deriva dal KCM. Come menzionato nella sezione precedente, CCM esegue i seguenti cicli di controllo:
* Node controller
* Route controller
* Service controller
#### Node controller
Il Node controller è responsabile per l'inizializzazione di un nodo ottenendo informazioni sui nodi in esecuzione nel cluster dal provider cloud. Il controller del nodo esegue le seguenti funzioni:
1. Inizializzare un nodo con le label zone/region specifiche per il cloud in uso.
2. Inizializzare un nodo con le specifiche, ad esempio, tipo e dimensione specifiche del cloud in uso.
3. Ottenere gli indirizzi di rete del nodo e l'hostname.
4. Nel caso in cui un nodo non risponda, controlla il cloud per vedere se il nodo è stato cancellato dal cloud. Se il nodo è stato eliminato dal cloud, elimina l'oggetto Nodo di Kubernetes.
#### Route controller
Il Route controller è responsabile della configurazione delle route nel cloud in modo che i container su nodi differenti del cluster Kubernetes possano comunicare tra loro. Il Route controller è utilizzabile solo dai cluster su Google Compute Engine.
#### Service Controller
Il Service Controller rimane in ascolto per eventi di creazione, aggiornamento ed eliminazione di servizi. In base allo stato attuale dei servizi in Kubernetes, configura i bilanciatori di carico forniti dal cloud (come gli ELB, i Google LB, o gli Oracle Cloud Infrastructure LB) per riflettere lo stato dei servizi in Kubernetes. Inoltre, assicura che i back-end dei bilanciatori di carico forniti dal cloud siano aggiornati.
### 2\. Kubelet
Il Node Controller contiene l'implementazione dipendente dal cloud della kubelet. Prima dell'introduzione del CCM, la kubelet era responsabile dell'inizializzazione di un nodo con dettagli dipendenti dallo specifico cloud come gli indirizzi IP, le label region/zone e le informazioni sul tipo di istanza. L'introduzione del CCM ha spostato questa operazione di inizializzazione dalla kubelet al CCM.
In questo nuovo modello, la kubelet inizializza un nodo senza informazioni specifiche del cloud. Tuttavia, aggiunge un blocco al nodo appena creato che rende il nodo non selezionabile per eseguire container finché il CCM non inizializza il nodo con le informazioni specifiche del cloud. Il CCM rimuove quindi questo blocco.
Sistema a plug-in
-----------------
Il cloud controller manager utilizza le interfacce di Go per consentire l'implementazione di implementazioni di qualsiasi cloud. In particolare, utilizza l'interfaccia CloudProvider definita [qui](https://github.com/kubernetes/cloud-provider/blob/9b77dc1c384685cb732b3025ed5689dd597a5971/cloud.go#L42-L62)
.
L'implementazione dei quattro controller generici evidenziati sopra, alcune strutture, l'interfaccia cloudprovider condivisa rimarranno nel core di Kubernetes. Le implementazioni specifiche per i vari cloud saranno costruite al di fuori del core e implementeranno le interfacce definite nel core.
Per ulteriori informazioni sullo sviluppo di plug-in, consultare [Developing Cloud Controller Manager](https://kubernetes.io/docs/tasks/administer-cluster/developing-cloud-controller-manager/)
.
Autorizzazione
--------------
Questa sezione dettaglia l'accesso richiesto dal CCM sui vari API objects per eseguire le sue operazioni.
### Node controller
Il Node controller funziona solo con oggetti di tipo Node. Richiede l'accesso completo per ottenere, elencare, creare, aggiornare, applicare patch, guardare ed eliminare oggetti di tipo Node.
v1/Node:
* Get
* List
* Create
* Update
* Patch
* Watch
* Delete
### Route controller
Il Route controller ascolta la creazione dell'oggetto Node e configura le rotte in modo appropriato. Richiede l'accesso in lettura agli oggetti di tipo Node.
v1/Node:
* Get
### Service controller
Il Service controller resta in ascolto per eventi di creazione, aggiornamento ed eliminazione di oggetti di tipo Servizi, e configura gli endpoint per tali Servizi in modo appropriato.
Per accedere ai Servizi, è necessario il permesso per list e watch. Per aggiornare i Servizi, sono necessari i permessi patch e update.
Per impostare gli endpoint per i Servizi, richiede i permessi create, list, get, watch, e update.
v1/Service:
* List
* Get
* Watch
* Patch
* Update
### Others
L'implementazione del core di CCM richiede l'accesso per creare eventi e, per garantire operazioni sicure, richiede l'accesso per creare ServiceAccounts.
v1/Event:
* Create
* Patch
* Update
v1/ServiceAccount:
* Create
L'RBAC ClusterRole per il CCM ha il seguente aspetto:
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: cloud-controller-manager
rules:
- apiGroups:
- ""
resources:
- events
verbs:
- create
- patch
- update
- apiGroups:
- ""
resources:
- nodes
verbs:
- '*'
- apiGroups:
- ""
resources:
- nodes/status
verbs:
- patch
- apiGroups:
- ""
resources:
- services
verbs:
- list
- patch
- update
- watch
- apiGroups:
- ""
resources:
- serviceaccounts
verbs:
- create
- apiGroups:
- ""
resources:
- persistentvolumes
verbs:
- get
- list
- update
- watch
- apiGroups:
- ""
resources:
- endpoints
verbs:
- create
- get
- list
- watch
- update
Vendor Implementations
----------------------
I seguenti fornitori di cloud hanno una implementazione di CCM:
* [Alibaba Cloud](https://github.com/kubernetes/cloud-provider-alibaba-cloud)
* [AWS](https://github.com/kubernetes/cloud-provider-aws)
* [Azure](https://github.com/kubernetes/cloud-provider-azure)
* [BaiduCloud](https://github.com/baidu/cloud-provider-baiducloud)
* [DigitalOcean](https://github.com/digitalocean/digitalocean-cloud-controller-manager)
* [GCP](https://github.com/kubernetes/cloud-provider-gcp)
* [Hetzner](https://github.com/hetznercloud/hcloud-cloud-controller-manager)
* [Linode](https://github.com/linode/linode-cloud-controller-manager)
* [OpenStack](https://github.com/kubernetes/cloud-provider-openstack)
* [Oracle](https://github.com/oracle/oci-cloud-controller-manager)
* [TencentCloud](https://github.com/TencentCloud/tencentcloud-cloud-controller-manager)
Cluster Administration
----------------------
Le istruzioni complete per la configurazione e l'esecuzione del CCM sono fornite [qui](https://kubernetes.io/docs/tasks/administer-cluster/running-cloud-controller/#cloud-controller-manager)
.
3.2.3 - Controller
==================
Nella robotica e nell'automazione, un _circuito di controllo_ (_control loop_) è un un'iterazione senza soluzione di continuità che regola lo stato di un sistema.
Ecco un esempio di un circuito di controllo: il termostato di una stanza.
Quando viene impostata la temperatura, si definisce attraverso il termostato lo _stato desiderato_. L'attuale temperatura nella stanza è invece lo _stato corrente_. Il termostato agisce per portare lo stato corrente il più vicino possibile allo stato desiderato accendendo e spegnendo le apparecchiature.
In Kubernetes, i _controller_ sono circuiti di controllo che osservano lo stato del [cluster](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-cluster "Un'insieme di macchine, chiamate nodi, che eseguono container gestiti da Kubernetes. Un cluster ha almeno un Worker Node.")
, e apportano o richiedono modifiche quando necessario. Ogni _controller_ prova a portare lo stato corrente del cluster verso lo stato desiderato.
Il modello del controller
-------------------------
Un _controller_ monitora almeno una tipo di risorsa registrata in Kubernetes. Questi [oggetti](https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/#kubernetes-objects)
hanno una proprietà chiamata _spec_ (specifica) che rappresenta lo stato desiderato. Il o i _controller_ per quella risorsa sono responsabili di mantenere lo stato corrente il più simile possibile rispetto allo stato desiderato.
Il _controller_ potrebbe eseguire l'azione relativa alla risorsa in questione da sé; più comunemente, in Kubernetes, un _controller_ invia messaggi all'[API server](https://kubernetes.io/it/docs/concepts/architecture/#kube-apiserver "Componente della Control plane che serve le Kubernetes API.")
che a sua volta li rende disponibili ad altri componenti nel cluster. Di seguito troverete esempi per questo scenario.
### Controllo attraverso l'API server
Il [Job](https://kubernetes.io/it/docs/concepts/workloads/controllers/jobs-run-to-completion "Uno o più lavori (task) che vengono eseguiti fino al loro completamento.")
_controller_ è un esempio di un _controller_ nativo in Kubernetes. I _controller_ nativi gestiscono lo stato interagendo con l'API server presente nel cluster.
Il Job è una risorsa di Kubernetes che lancia uno o più [Pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
per eseguire un lavoro (task) e poi fermarsi.
(Una volta che è stato [schedulato](https://kubernetes.io/docs/concepts/scheduling-eviction/)
, un oggetto _Pod_ diventa parte dello stato desisderato di un dato _kubelet_).
Quando il Job _controller_ vede un nuovo lavoro da svolgere si assicura che, da qualche parte nel cluster, i _kubelet_ anche sparsi su più nodi eseguano il numero corretto di _Pod_ necessari per eseguire il lavoro richiesto. Il Job _controller_ non esegue direttamente alcun _Pod_ o _container_ bensì chiede all'API server di creare o rimuovere i _Pod_. Altri componenti appartenenti al [control plane](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-control-plane "Lo strato per l'orchestrazione dei container che espone le API e interfaccie per definere, deploy, e gestione del ciclo di vita dei container.")
reagiscono in base alle nuove informazioni (ci sono nuovi _Pod_ da creare e gestire) e cooperano al completamento del job.
Dopo che un nuovo Job è stato creato, lo stato desiderato per quel Job è il suo completamento. Il Job _controller_ fa sì che lo stato corrente per quel Job sia il più vicino possibile allo stato desiderato: creare _Pod_ che eseguano il lavoro che deve essere effettuato attraverso il Job, così che il Job sia prossimo al completamento.
I _controller_ aggiornano anche gli oggetti che hanno configurato. Ad esempio: una volta che il lavoro relativo ad un dato Job è stato completato, il Job _controller_ aggiorna l'oggetto Job segnandolo come `Finished`.
(Questo è simile allo scenario del termostato che spegne un certo led per indicare che ora la stanza ha raggiungo la temperatura impostata)
### Controllo diretto
A differenza del Job, alcuni _controller_ devono eseguire delle modifiche a parti esterne al cluster.
Per esempio, se viene usato un circuito di controllo per assicurare che ci sia un numero sufficiente di [Nodi](https://kubernetes.io/it/docs/concepts/architecture/nodes/ "Un node è una macchina worker in Kubernetes.")
nel cluster, allora il _controller_ ha bisogno che qualcosa al di fuori del cluster configuri i nuovi _Nodi_ quando sarà necessario.
I _controller_ che interagiscono con un sistema esterno trovano il loro stato desiderato attraverso l'API server, quindi comunicano direttamente con un sistema esterno per portare il loro stato corrente più in linea possibile con lo stato desiderato
(In realtà c'è un _controller_ che scala orizzontalmente i nodi nel cluster. Vedi [Cluster autoscaling](https://kubernetes.io/docs/tasks/administer-cluster/cluster-management/#cluster-autoscaling)
).
Stato desiderato versus corrente
--------------------------------
Kubernetes ha una visione _cloud-native_ dei sistemi, ed è in grado di gestire continue modifiche.
Il cluster viene modificato continuamente durante la sua attività ed il _circuito di controllo_ è in grado di risolvere automaticamente i possibili guasti.
Fino a che i _controller_ del cluster sono in funzione ed in grado di apportare le dovute modifiche, non è rilevante che lo stato complessivo del cluster sia o meno stabile.
Progettazione
-------------
Come cardine della sua progettazione, Kubernetes usa vari _controller_ ognuno dei quali è responsabile per un particolare aspetto dello stato del cluster. Più comunemente, un dato _circuito di controllo_ (_controller_) usa un tipo di risorsa per il suo stato desiderato, ed utilizza anche risorse di altro tipo per raggiungere questo stato desiderato. Per esempio il Job _controller_ tiene traccia degli oggetti di tipo _Job_ (per scoprire nuove attività da eseguire) e degli oggetti di tipo _Pod_ (questi ultimi usati per eseguire i _Job_, e quindi per controllare quando il loro lavoro è terminato). In questo caso, qualcos'altro crea i _Job_, mentre il _Job_ _controller_ crea i _Pod_.
È utile avere semplici _controller_ piuttosto che un unico, monolitico, _circuito di controllo_. I _controller_ possono guastarsi, quindi Kubernetes è stato disegnato per gestire questa eventualità.
#### Nota:
Ci possono essere diversi _controller_ che creato o aggiornano lo stesso tipo di oggetti. Dietro le quinte, i _controller_ di Kubernetes si preoccupano esclusivamente delle risorse (di altro tipo) collegate alla risorsa primaria da essi controllata.
Per esempio, si possono avere _Deployment_ e _Job_; entrambe creano _Pod_. Il Job _controller_ non distrugge i _Pod_ creati da un _Deployment_, perché ci sono informazioni (_[labels](https://kubernetes.io/it/docs/concepts/overview/working-with-objects/labels "Tags di oggetti con attributi identificativi che sono significativi e pertinenti per gli utenti.")
_) che vengono usate dal _controller_ per distinguere i _Pod_.
I modi per eseguire i _controller_
----------------------------------
Kubernetes annovera un insieme di _controller_ nativi che sono in esecuzione all'interno del [kube-controller-manager](https://kubernetes.io/it/docs/reference/command-line-tools-reference/kube-controller-manager/ "Componente della Control Plane che gestisce i controller.")
. Questi _controller_ nativi forniscono importanti funzionalità di base.
Il Deployment _controller_ ed il Job _controller_ sono esempi di _controller_ che vengono forniti direttamente da Kubernetes stesso (ovvero _controller_ "nativi"). Kubernetes consente di eseguire un _piano di controllo_(_control plane_) resiliente, di modo che se un dei _controller_ nativi dovesse fallire, un'altra parte del piano di controllo si occuperà di eseguire quel lavoro.
Al fine di estendere Kubernetes, si possono avere _controller_ in esecuzione al di fuori del piano di controllo. Oppure, se si desidera, è possibile scriversi un nuovo _controller_. È possibile eseguire il proprio controller come una serie di _Pod_, oppure esternamente rispetto a Kubernetes. Quale sia la soluzione migliore, dipende dalla responsabilità di un dato controller.
Voci correlate
--------------
* Leggi in merito [Kubernetes control plane](https://kubernetes.io/it/docs/concepts/#kubernetes-control-plane)
* Scopri alcune delle basi degli [oggetti di Kubernetes](https://kubernetes.io/it/docs/concepts/#kubernetes-objects)
* Per saperne di più riguardo alle [API di Kubernetes](https://kubernetes.io/it/docs/concepts/overview/kubernetes-api/)
* Se vuoi creare un tuo _controller_, guarda [i modelli per l'estensibilità](https://kubernetes.io/docs/concepts/extend-kubernetes/extend-cluster/#extension-patterns)
in Estendere Kubernetes.
3.3 - Containers
================
La tecnologia per distribuire un'applicazione insieme con le dipendenze necessarie per la sua esecuzione.
Ogni _container_ che viene eseguito è riproducibile; la pratica di includere le dipendenze all'interno di ciascuno _container_ permette di ottenere sempre lo stesso risultato ad ogni esecuzione del medesimo _container_.
I _Container_ permettono di disaccoppiare le applicazioni dall'infrastruttura del host su cui vengono eseguite. Questo approccio rende più facile il _deployment_ su cloud o sitemi operativi differenti tra loro.
Immagine di container
---------------------
L'[immagine di un container](https://kubernetes.io/it/docs/concepts/containers/images/)
e' un pacchetto software che contiene tutto ciò che serve per eseguire un'applicazione: il codice sorgente e ciascun _runtime_ necessario, librerie applicative e di sistema, e le impostazioni predefinite per ogni configurazione necessaria.
Un _container_ è immutabile per definizione: non è possibile modificare il codice di un _container_ in esecuzione. Se si ha un'applicazione containerizzata e la si vuole modificare, si deve costruire un nuovo _container_ che includa il cambiamento desiderato, e quindi ricreare il _container_ partendo dalla nuova immagine aggiornata.
Container runtimes
------------------
Il container runtime è il software che è responsabile per l'esecuzione dei container.
Kubernetes supporta diversi container runtimes: [Docker](http://www.docker.com/)
, [containerd](https://containerd.io/)
, [cri-o](https://cri-o.io/)
, [rktlet](https://github.com/kubernetes-incubator/rktlet)
e tutte le implementazioni di [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Voci correlate
--------------
* Leggi in merito [immagine di container](https://kubernetes.io/it/docs/concepts/containers/images/)
* Leggi in merito [Pods](https://kubernetes.io/docs/concepts/workloads/pods/)
3.3.1 - Immagini
================
L'immagine di un container rappresenta dati binari che incapsulano un'applicazione e tutte le sue dipendenze software. Le immagini sono costituite da pacchetti software eseguibili che possono essere avviati in modalità standalone e su cui si possono fare ipotesi ben precise circa l'ambiente in cui vengono eseguiti.
Tipicamente viene creata un'immagine di un'applicazione ed effettuato il _push_ su un registry (un repository pubblico di immagini) prima di poterne fare riferimento esplicito in un [Pod](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
Questa pagina va a delineare nello specifico il concetto di immagine di un container.
I nomi delle immagini
---------------------
Alle immagini dei container vengono normalmente attribuiti nomi come `pause`, `example/mycontainer`, o `kube-apiserver`. Le immagini possono anche contenere l'hostname del registry in cui le immagini sono pubblicate; ad esempio: `registro.fittizio.esempio/nomeimmagine`, ed è possibile che sia incluso nel nome anche il numero della porta; ad esempio: `registro.fittizio.esempio:10443/nomeimmagine`.
Se non si specifica l'hostname di un registry, Kubernetes assume che ci si riferisca al registry pubblico di Docker.
Dopo la parte relativa al nome dell'immagine si può aggiungere un _tag_ (come comunemente avviene per comandi come `docker` e `podman`). I tag permettono l'identificazione di differenti versioni della stessa serie di immagini.
I tag delle immagini sono composti da lettere minuscole e maiuscole, numeri, underscore (`_`), punti (`.`), e trattini (`-`).
Esistono regole aggiuntive relative a dove i caratteri separatori (`_`, `-`, and `.`) possano essere inseriti nel tag di un'immagine. Se non si specifica un tag, Kubernetes assume il tag `latest` che va a definire l'immagine disponibile più recente.
#### Attenzione:
Evitate di utilizzare il tag `latest` quando si rilasciano dei container in produzione, in quanto risulta difficile tracciare quale versione dell'immagine sia stata avviata e persino più difficile effettuare un rollback ad una versione precente.
Invece, meglio specificare un tag specifico come ad esempio `v1.42.0`.
Aggiornamento delle immagini
----------------------------
Quando un [Deployment](https://kubernetes.io/it/docs/concepts/workloads/controllers/deployment/ "Gestisce una applicazione replicata nel tuo cluster.")
, [StatefulSet](https://kubernetes.io/it/docs/concepts/workloads/controllers/statefulset/ "Gestisce deployment e la scalabilità di un gruppo di Pod, con storage e identificativi persistenti per ogni Pod.")
, Pod, o qualsiasi altro oggetto che includa un Pod template viene creato per la prima volta, la policy di default per il pull di tutti i container nel Pod è impostata su `IfNotPresent` (se non presente) se non specificato diversamente. Questa policy permette al [kubelet](https://kubernetes.io/it/docs/reference/generated/kubelet "Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.")
di evitare di fare il pull di un'immagine se questa è già presente.
Se necessario, si può forzare il pull in ogni occasione in uno dei seguenti modi:
* impostando `imagePullPolicy` (specifica per il pull delle immagini) del container su `Always` (sempre).
* omettendo `imagePullPolicy` ed usando il tag `:latest` (più recente) per l'immagine da utilizzare; Kubernetes imposterà la policy su `Always` (sempre).
* omettendo `imagePullPolicy` ed il tag per l'immagine da utilizzare.
* abilitando l'admission controller [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
.
#### Nota:
Il valore dell'impostazione `imagePullPolicy` del container è sempre presente quando l'oggetto viene creato per la prima volta e non viene aggiornato se il tag dell'immagine dovesse cambiare successivamente.
Ad esempio, creando un Deployment con un'immagine il cui tag _non_ è `:latest`, e successivamente aggiornando il tag di quell'immagine a `:latest`, il campo `imagePullPolicy` _non_ cambierà su `Always`. È necessario modificare manualmente la policy di pull di ogni oggetto dopo la sua creazione.
Quando `imagePullPolicy` è definito senza un valore specifico, esso è impostato su `Always`.
Multi-architecture support nelle immagini
-----------------------------------------
Oltre a fornire immagini binarie, un _container registry_ può fornire un [indice delle immagini disponibili per un container](https://github.com/opencontainers/image-spec/blob/master/image-index.md)
. L'indice di un'immagine può puntare a più [file manifest](https://github.com/opencontainers/image-spec/blob/master/manifest.md)
ciascuno per una versione specifica dell'architettura di un container. L'idea è che si può avere un unico nome per una stessa immagine (ad esempio: `pause`, `example/mycontainer`, `kube-apiserver`) e permettere a diversi sistemi di recuperare l'immagine binaria corretta a seconda dell'architettura della macchina che la sta utilizzando.
Kubernetes stesso tipicamente nomina le immagini dei container tramite il suffisso `-$(ARCH)`. Per la garantire la retrocompatibilità è meglio generare le vecchie immagini con dei suffissi. L'idea è quella di generare, ad esempio, l'immagine `pause` con un manifest che include tutte le architetture supportate, affiancata, ad esempio, da `pause-amd64` che è retrocompatibile per le vecchie configurazioni o per quei file YAML in cui sono specificate le immagini con i suffissi.
Utilizzare un private registry
------------------------------
I private registry possono richiedere l'utilizzo di chiavi per accedere alle immagini in essi contenute.
Le credenziali possono essere fornite in molti modi:
* configurando i nodi in modo tale da autenticarsi al private registry
* tutti i pod possono acquisire informazioni da qualsiasi private registry configurato
* è necessario che l'amministratore del cluster configuri i nodi in tal senso
* tramite pre-pulled images (immagini pre-caricate sui nodi)
* tutti i pod possono accedere alle immagini salvate sulla cache del nodo a cui si riferiscono
* è necessario effettuare l'accesso come root di sistema su ogni nodo per inserire questa impostazione
* specificando _ImagePullSecrets_ su un determinato pod
* solo i pod che forniscono le proprie chiavi hanno la possibilità di accedere al private registry
* tramite estensioni locali o specifiche di un _Vendor_
* se si sta utilizzando una configurazione personalizzata del nodo oppure se manualmente, o tramite il _cloud provider_, si implementa un meccanismo di autenticazione del nodo presso il _container registry_.
Di seguito la spiegazione dettagliata di queste opzioni.
### Configurazione dei nodi per l'autenticazione ad un private registry
Se si sta utilizzando Docker sui nodi, si può configurare il _Docker container runtime_ per autenticare il nodo presso un private container registry.
Questo è un approccio possibile se si ha il controllo sulle configurazioni del nodo.
#### Nota:
Kubernetes di default supporta solo le sezioni `auths` e `HttpHeaders` nelle configurazioni relative a Docker. Eventuali _helper_ per le credenziali di Docker (`credHelpers` o `credsStore`) non sono supportati.
Docker salva le chiavi per i registri privati in `$HOME/.dockercfg` oppure nel file `$HOME/.docker/config.json`. Inserendo lo stesso file nella lista seguente, kubelet lo utilizzerà per recuperare le credenziali quando deve fare il _pull_ delle immagini.
* `{--root-dir:-/var/lib/kubelet}/config.json`
* `{cwd of kubelet}/config.json`
* `${HOME}/.docker/config.json`
* `/.docker/config.json`
* `{--root-dir:-/var/lib/kubelet}/.dockercfg`
* `{cwd of kubelet}/.dockercfg`
* `${HOME}/.dockercfg`
* `/.dockercfg`
#### Nota:
Potrebbe essere necessario impostare `HOME=/root` esplicitamente come variabile d'ambiente del processo _kubelet_.
Di seguito i passi consigliati per configurare l'utilizzo di un private registry da parte dei nodi del _cluster_. In questo esempio, eseguire i seguenti comandi sul proprio desktop/laptop:
1. Esegui `docker login [server]` per ogni _set_ di credenziali che vuoi utilizzare. Questo comando aggiornerà `$HOME/.docker/config.json` sul tuo PC.
2. Controlla il file `$HOME/.docker/config.json` in un editor di testo per assicurarti che contenga le credenziali che tu voglia utilizzare.
3. Recupera la lista dei tuoi nodi; ad esempio:
* se vuoi utilizzare i nomi: `nodes=$( kubectl get nodes -o jsonpath='{range.items[*].metadata}{.name} {end}' )`
* se vuoi recuperare gli indirizzi IP: `nodes=$( kubectl get nodes -o jsonpath='{range .items[*].status.addresses[?(@.type=="ExternalIP")]}{.address} {end}' )`
4. Copia il tuo file locale `.docker/config.json` in uno dei path sopra riportati nella lista di ricerca.
* ad esempio, per testare il tutto: `for n in $nodes; do scp ~/.docker/config.json root@"$n":/var/lib/kubelet/config.json; done`
#### Nota:
Per i cluster di produzione, utilizza un configuration management tool per poter applicare le impostazioni su tutti i nodi laddove necessario.
Puoi fare una verifica creando un Pod che faccia uso di un'immagine privata; ad esempio:
kubectl apply -f - < --docker-server=DOCKER_REGISTRY_SERVER --docker-username=DOCKER_USER --docker-password=DOCKER_PASSWORD --docker-email=DOCKER_EMAIL
Se possiedi il file delle credenziali per Docker, anziché utilizzare il comando quì sopra puoi importare il file di credenziali come un Kubernetes [Secrets](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-secret "Contiene informazioni sensibili, come passwords, token OAuth, e chiavi ssh.")
.
[Creare un Secret a partire da credenziali Docker](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/#registry-secret-existing-credentials)
fornisce la spiegazione dettagliata su come fare.
Ciò è particolarmente utile se si utilizzano più _container registry_ privati, in quanto il comando `kubectl create secret docker-registry` genera un Secret che funziona con un solo private registry.
#### Nota:
I Pod possono fare riferimento ai Secret per il pull delle immagini soltanto nel proprio _namespace_, quindi questo procedimento deve essere svolto per ogni _namespace_.
#### Fare riferimento ad imagePullSecrets in un Pod
È possibile creare pod che referenzino quel Secret aggiungendo la sezione `imagePullSecrets` alla definizione del Pod.
Ad esempio:
cat < pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: foo
namespace: awesomeapps
spec:
containers:
- name: foo
image: janedoe/awesomeapp:v1
imagePullSecrets:
- name: myregistrykey
EOF
cat <> ./kustomization.yaml
resources:
- pod.yaml
EOF
Questo deve esser fatto per ogni Pod che utilizzi un private registry.
Comunque, le impostazioni relative a questo campo possono essere automatizzate inserendo la sezione _imagePullSecrets_ nella definizione della risorsa [ServiceAccount](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/)
.
Visitare la pagina [Aggiungere ImagePullSecrets ad un Service Account](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#add-imagepullsecrets-to-a-service-account)
per istruzioni più dettagliate.
Puoi utilizzarlo in congiunzione al file `.docker/config.json` configurato per ogni nodo. In questo caso, si applicherà un _merge_ delle credenziali.
Casi d'uso
----------
Ci sono varie soluzioni per configurare i private registry. Di seguito, alcuni casi d'uso comuni e le soluzioni suggerite.
1. Cluster in cui sono utilizzate soltanto immagini non proprietarie (ovvero _open-source_). In questo caso non sussiste il bisogno di nascondere le immagini.
* Utilizza immagini pubbliche da Docker hub.
* Nessuna configurazione richiesta.
* Alcuni _cloud provider_ mettono in _cache_ o effettuano il _mirror_ di immagini pubbliche, il che migliora la disponibilità delle immagini e ne riduce il tempo di _pull_.
2. Cluster con container avviati a partire da immagini proprietarie che dovrebbero essere nascoste a chi è esterno all'organizzazione, ma visibili a tutti gli utenti abilitati nel cluster.
* Utilizza un private [Docker registry](https://docs.docker.com/registry/)
.
* Esso può essere ospitato da [Docker Hub](https://hub.docker.com/signup)
, o da qualche altra piattaforma.
* Configura manualmente il file .docker/config.json su ogni nodo come descritto sopra.
* Oppure, avvia un private registry dietro il tuo firewall con accesso in lettura libero.
* Non è necessaria alcuna configurazione di Kubernetes.
* Utilizza un servizio di _container registry_ che controlli l'accesso alle immagini
* Esso funzionerà meglio con una configurazione del cluster basata su _autoscaling_ che con una configurazione manuale del nodo.
* Oppure, su un cluster dove la modifica delle configurazioni del nodo non è conveniente, utilizza `imagePullSecrets`.
3. Cluster con immagini proprietarie, alcune delle quali richiedono un controllo sugli accessi.
* Assicurati che l'_admission controller_ [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
sia attivo. Altrimenti, tutti i Pod potenzialmente possono avere accesso a tutte le immagini.
* Sposta i dati sensibili un un _Secret_, invece di inserirli in un'immagine.
4. Un cluster multi-tenant dove ogni tenant necessiti di un private registry.
* Assicurati che l'_admission controller_ [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)
sia attivo. Altrimenti, tutti i Pod di tutti i tenant potrebbero potenzialmente avere accesso a tutte le immagini.
* Avvia un private registry che richieda un'autorizzazione all'accesso.
* Genera delle credenziali di registry per ogni tenant, inseriscile in dei _Secret_, e popola i _Secret_ per ogni _namespace_ relativo ad ognuno dei tenant.
* Il singolo tenant aggiunge così quel _Secret_ all'impostazione _imagePullSecrets_ di ogni _namespace_.
Se si ha la necessità di accedere a più registri, si può generare un _Secret_ per ognuno di essi. Kubelet farà il _merge_ di ogni `imagePullSecrets` in un singolo file virtuale `.docker/config.json`.
Voci correlate
--------------
* Leggi [OCI Image Manifest Specification](https://github.com/opencontainers/image-spec/blob/master/manifest.md)
3.3.2 - Container Environment
=============================
Questa pagina descrive le risorse disponibili nei Container eseguiti in Kubernetes.
Container environment
---------------------
Quando si esegue un Container in Kubernetes, le seguenti risorse sono rese disponibili:
* Un filesystem, composto dal file system dell'[image](https://kubernetes.io/it/docs/concepts/containers/images/)
e da uno o più [volumes](https://kubernetes.io/docs/concepts/storage/volumes/)
.
* Una serie di informazioni sul Container stesso.
* Una serie di informazioni sugli oggetti nel cluster.
### Informazioni sul Container
L' _hostname_ di un Container è il nome del Pod all'interno del quale è eseguito il Container. È consultabile tramite il comando `hostname` o tramite la funzione [`gethostname`](http://man7.org/linux/man-pages/man2/gethostname.2.html)
disponibile in libc.
Il nome del Pod e il namespace possono essere resi disponibili come environment variables attraverso l'uso delle [downward API](https://kubernetes.io/docs/tasks/inject-data-application/downward-api-volume-expose-pod-information/)
.
Gli utenti possono aggiungere altre environment variables nella definizione del Pod; anche queste saranno disponibili nel Container come tutte le altre environment variables definite staticamente nella Docker image.
### Informazioni sul cluster
Al momento della creazione del Container è generata una serie di environment variables con la lista di servizi in esecuzione nel cluster. Queste environment variables rispettano la sintassi dei Docker links.
Per un servizio chiamato _foo_ che è in esecuzione in un Container di nome _bar_, le seguenti variabili sono generate:
FOO_SERVICE_HOST=
FOO_SERVICE_PORT=
I servizi hanno un indirizzo IP dedicato e sono disponibili nei Container anche via DNS se il [DNS addon](http://releases.k8s.io/master/cluster/addons/dns/)
è installato nel cluster.
Voci correlate
--------------
* Approfondisci [Container lifecycle hooks](https://kubernetes.io/it/docs/concepts/containers/container-lifecycle-hooks/)
.
* Esegui un tutorial su come [definire degli handlers per i Container lifecycle events](https://kubernetes.io/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/)
.
3.3.3 - Container Lifecycle Hooks
=================================
Questa pagina descrive come i Container gestiti con kubelet possono utilizzare il lifecycle hook framework dei Container per l'esecuzione di codice eseguito in corrispondenza di alcuni eventi durante il loro ciclo di vita.
Overview
--------
Analogamente a molti framework di linguaggi di programmazione che hanno degli hooks legati al ciclo di vita dei componenti, come ad esempio Angular, Kubernetes fornisce ai Container degli hook legati al loro ciclo di vita dei Container. Gli hook consentono ai Container di essere consapevoli degli eventi durante il loro ciclo di gestione ed eseguire del codice implementato in un handler quando il corrispondente hook viene eseguito.
Container hooks
---------------
Esistono due tipi di hook che vengono esposti ai Container:
`PostStart`
Questo hook viene eseguito successivamente alla creazione del container. Tuttavia, non vi è garanzia che questo hook venga eseguito prima dell'ENTRYPOINT del container. Non vengono passati parametri all'handler.
`PreStop`
Questo hook viene eseguito prima della terminazione di un container a causa di una richiesta API o di un evento di gestione, come ad esempio un fallimento delle sonde di liveness/startup, preemption, risorse contese e altro. Una chiamata all'hook di `PreStop` fallisce se il container è in stato terminated o completed e l'hook deve finire prima che possa essere inviato il segnale di TERM per fermare il container. Il conto alla rovescia per la terminazione del Pod (grace period) inizia prima dell'esecuzione dell'hook `PreStop`, quindi indipendentemente dall'esito dell'handler, il container terminerà entro il grace period impostato. Non vengono passati parametri all'handler.
Una descrizione più dettagliata riguardante al processo di terminazione dei Pod può essere trovata in [Terminazione dei Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination)
.
### Implementazione degli hook handler
I Container possono accedere a un hook implementando e registrando un handler per tale hook. Ci sono due tipi di handler che possono essere implementati per i Container:
* Exec - Esegue un comando specifico, tipo `pre-stop.sh`, all'interno dei cgroup e namespace del Container. Le risorse consumate dal comando vengono contate sul Container.
* HTTP - Esegue una richiesta HTTP verso un endpoint specifico del Container.
### Esecuzione dell'hook handler
Quando viene richiamato l'hook legato al lifecycle del Container, il sistema di gestione di Kubernetes esegue l'handler secondo l'azione dell'hook, `httpGet` e `tcpSocket` vengono eseguiti dal processo kubelet, mentre `exec` è eseguito nel Container.
Le chiamate agli handler degli hook sono sincrone rispetto al contesto del Pod che contiene il Container. Questo significa che per un hook `PostStart`, l'ENTRYPOINT e l'hook si attivano in modo asincrono. Tuttavia, se l'hook impiega troppo tempo per essere eseguito o si blocca, il container non può raggiungere lo stato di `running`.
Gli hook di `PreStop` non vengono eseguiti in modo asincrono dall'evento di stop del container; l'hook deve completare la sua esecuzione prima che l'evento TERM possa essere inviato. Se un hook di `PreStop` si blocca durante la sua esecuzione, la fase del Pod rimarrà `Terminating` finchè il Pod non sarà rimosso forzatamente dopo la scadenza del suo `terminationGracePeriodSeconds`. Questo grace period si applica al tempo totale necessario per effettuare sia l'esecuzione dell'hook di `PreStop` che per l'arresto normale del container. Se, per esempio, il `terminationGracePeriodSeconds` è di 60, e l'hook impiega 55 secondi per essere completato, e il container impiega 10 secondi per fermarsi normalmente dopo aver ricevuto il segnale, allora il container verrà terminato prima di poter completare il suo arresto, poiché `terminationGracePeriodSeconds` è inferiore al tempo totale (55+10) necessario perché queste due cose accadano.
Se un hook `PostStart` o `PreStop` fallisce, allora il container viene terminato.
Gli utenti dovrebbero mantenere i loro handler degli hook i più leggeri possibili. Ci sono casi, tuttavia, in cui i comandi di lunga durata hanno senso, come il salvataggio dello stato del container prima della sua fine.
### Garanzia della chiamata dell'hook
La chiamata degli hook avviene _almeno una volta_, il che significa che un hook può essere chiamato più volte da un dato evento, come per `PostStart` o `PreStop`. Sta all'implementazione dell'hook gestire correttamente questo aspetto.
Generalmente, vengono effettuate singole chiamate agli hook. Se, per esempio, la destinazione di hook HTTP non è momentaneamente in grado di ricevere traffico, non c'è alcun tentativo di re invio. In alcuni rari casi, tuttavia, può verificarsi una doppia chiamata. Per esempio, se un kubelet si riavvia nel mentre dell'invio di un hook, questo potrebbe essere chiamato per una seconda volta dopo che il kubelet è tornato in funzione.
### Debugging Hook handlers
I log di un handler di hook non sono esposti negli eventi del Pod. Se un handler fallisce per qualche ragione, trasmette un evento. Per il `PostStart`, questo è l'evento di `FailedPostStartHook`, e per il `PreStop`, questo è l'evento di `FailedPreStopHook`. Puoi vedere questi eventi eseguendo `kubectl describe pod `. Ecco alcuni esempi di output di eventi dall'esecuzione di questo comando:
Events:
FirstSeen LastSeen Count From SubObjectPath Type Reason Message
--------- -------- ----- ---- ------------- -------- ------ -------
1m 1m 1 {default-scheduler } Normal Scheduled Successfully assigned test-1730497541-cq1d2 to gke-test-cluster-default-pool-a07e5d30-siqd
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulling pulling image "test:1.0"
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Created Created container with docker id 5c6a256a2567; Security:[seccomp=unconfined]
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulled Successfully pulled image "test:1.0"
1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Started Started container with docker id 5c6a256a2567
38s 38s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 5c6a256a2567: PostStart handler: Error executing in Docker Container: 1
37s 37s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 8df9fdfd7054: PostStart handler: Error executing in Docker Container: 1
38s 37s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} Warning FailedSync Error syncing pod, skipping: failed to "StartContainer" for "main" with RunContainerError: "PostStart handler: Error executing in Docker Container: 1"
1m 22s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Warning FailedPostStartHook
Voci correlate
--------------
* Approfondisci [Container environment](https://kubernetes.io/it/docs/concepts/containers/container-environment/)
.
* Esegui un tutorial su come [definire degli handlers per i Container lifecycle events](https://kubernetes.io/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/)
.
3.4 - Configurazione
====================
Risorse che fornisce Kubernetes per configurare i Pods.
3.4.1 - ConfigMaps
==================
La ConfigMap è un oggetto API usato per memorizzare dati non riservati in coppie chiave-valore. I [Pods](https://kubernetes.io/it/docs/concepts/workloads/pods/pod-overview/ "Un Pod rappresenta un gruppo di container nel tuo cluster.")
possono utilizzare le ConfigMaps come variabili d'ambiente, argomenti da riga di comando, o come files di configurazione all'interno di un [Volume](https://kubernetes.io/it/docs/concepts/storage/volumes/ "Una cartella contenente dati, accessibile dai containers all'interno del pod.")
.
La ConfigMap ti permette di disaccoppiare le configurazioni specifiche per ambiente dalle [immagini del container](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-image "Istanza archiviata di un cointainer che contiene un insieme di software e librerie necessarie per eseguire l'applicazione.")
, cosicchè le tue applicazioni siano facilmente portabili.
#### Attenzione:
La ConfigMap non fornisce riservatezza o cifratura dei dati. Se i dati che vuoi salvare sono confidenziali, usa un [Secret](https://kubernetes.io/it/docs/reference/glossary/?all=true#term-secret "Contiene informazioni sensibili, come passwords, token OAuth, e chiavi ssh.")
piuttosto che una ConfigMap, o usa uno strumento di terze parti per tenere privati i tuoi dati.
Utilizzo
--------
Usa una ConfigMap per tenere separati i dati di configurazione dal codice applicativo.
Per esempio, immagina che stai sviluppando un'applicazione che puoi eseguire sul tuo computer (per lo sviluppo) e sul cloud (per gestire il traffico reale). Puoi scrivere il codice puntando a una variabile d'ambiente chiamata `DATABASE_HOST`. Localmente, puoi settare quella variabile a `localhost`. Nel cloud, la puoi settare referenziando il [Service](https://kubernetes.io/it/docs/concepts/services-networking/service/ "A way to expose an application running on a set of Pods as a network service.")
di Kubernetes che espone la componente del database sul tuo cluster. Ciò ti permette di andare a recuperare l'immagine del container eseguita nel cloud e fare il debug dello stesso codice localmente se necessario.
La ConfigMap non è pensata per sostenere una gran mole di dati. I dati memorizzati su una ConfigMap non possono superare 1 MiB. Se hai bisogno di memorizzare delle configurazioni che superano questo limite, puoi considerare di montare un volume oppure usare un database o un file service separato.
Oggetto ConfigMap
-----------------
La ConfigMap è un [oggetto](https://kubernetes.io/docs/concepts/overview/working-with-objects/kubernetes-objects/)
API che ti permette di salvare configurazioni per poi poter essere riutilizzate da altri oggetti. A differenza di molti oggetti di Kubernetes che hanno una `spec`, la ConfigMap ha i campi `data` e `binaryData`. Questi campi accettano le coppie chiave-valore come valori. Entrambi i campi `data` e `binaryData` sono opzionali. Il campo `data` è pensato per contenere le stringhe UTF-8 mentre il campo `binaryData` è pensato per contenere dati binari come le stringhe codificate in base64.
Il nome di una ConfigMap deve essere un nome valido per un sottodominio DNS.
Ogni chiave sotto il campo `data` o `binaryData` deve consistere di caratteri alfanumerici, `-`, `_` o `.`. Le chiavi salvate sotto `data` non devono coincidere con le chiavi nel campo `binaryData`.
Partendo dalla versione 1.19, puoi aggiungere il campo `immutable` alla definizione di ConfigMap per creare una [ConfigMap immutabile](https://kubernetes.io/it/docs/_print/#configmap-immutable)
.
ConfigMaps e Pods
-----------------
Puoi scrivere una `spec` del Pod che si riferisce a una ConfigMap e configurare il o i containers in quel Pod sulla base dei dati presenti nella ConfigMap. Il Pod e la ConfigMap devono essere nello stesso Namespace.
#### Nota:
La `spec` di un [Pod statico](https://kubernetes.io/it/docs/tasks/configure-pod-container/static-pod/ "A pod managed directly by the kubelet daemon on a specific node.")
non può riferirsi a una ConfigMap o ad altri oggetti API.
Questo è un esempio di una ConfigMap che ha alcune chiavi con valori semplici, e altre chiavi dove il valore ha il formato di un frammento di configurazione.
apiVersion: v1
kind: ConfigMap
metadata:
name: game-demo
data:
# chiavi simili a proprietà; ogni chiave mappa un valore semplice
player_initial_lives: "3"
ui_properties_file_name: "user-interface.properties"
# chiavi simili a files
game.properties: |
enemy.types=aliens,monsters
player.maximum-lives=5
user-interface.properties: |
color.good=purple
color.bad=yellow
allow.textmode=true
Ci sono quattro modi differenti con cui puoi usare una ConfigMap per configurare un container all'interno di un Pod:
1. Argomento da riga di comando come entrypoint di un container
2. Variabile d'ambiente di un container
3. Aggiungere un file in un volume di sola lettura, per fare in modo che l'applicazione lo legga
4. Scrivere il codice da eseguire all'interno del Pod che utilizza l'API di Kubernetes per leggere la ConfigMap
Questi metodologie differenti permettono di utilizzare diversi metodi per modellare i dati che saranno consumati. Per i primi tre metodi, il [kubelet](https://kubernetes.io/it/docs/reference/generated/kubelet "Un agente che è eseguito su ogni nodo del cluster. Si assicura che i container siano eseguiti in un pod.")
utilizza i dati della ConfigMap quando lancia il container (o più) in un Pod.
Per il quarto metodo dovrai scrivere il codice per leggere la ConfigMap e i suoi dati. Comunque, poiché stai utilizzando l'API di Kubernetes direttamente, la tua applicazione può sottoscriversi per ottenere aggiornamenti ogniqualvolta la ConfigMap cambia, e reagire quando ciò accade. Accedendo direttamente all'API di Kubernetes, questa tecnica ti permette anche di accedere a una ConfigMap in namespace differenti.
Ecco un esempio di Pod che usa i valori da `game-demo` per configurare il container:
apiVersion: v1
kind: Pod
metadata:
name: configmap-demo-pod
spec:
containers:
- name: demo
image: alpine
command: ["sleep", "3600"]
env:
# Definire la variabile d'ambiente
- name: PLAYER_INITIAL_LIVES # Notare che il case qui è differente
# dal nome della key nella ConfigMap.
valueFrom:
configMapKeyRef:
name: game-demo # La ConfigMap da cui proviene il valore.
key: player_initial_lives # La chiave da recuperare.
- name: UI_PROPERTIES_FILE_NAME
valueFrom:
configMapKeyRef:
name: game-demo
key: ui_properties_file_name
volumeMounts:
- name: config
mountPath: "/config"
readOnly: true
volumes:
# Settare i volumi al livello del Pod, in seguito montarli nei containers all'interno del Pod
- name: config
configMap:
# Fornire il nome della ConfigMap che vuoi montare.
name: game-demo
# Una lista di chiavi dalla ConfigMap per essere creata come file
items:
- key: "game.properties"
path: "game.properties"
- key: "user-interface.properties"
path: "user-interface.properties"
Una ConfigMap non differenzia tra le proprietà di una singola linea e un file con più linee e valori. L'importante è il modo in cui i Pods e gli altri oggetti consumano questi valori.
Per questo esempio, definire un volume e montarlo all'interno del container `demo` come `/config` crea due files, `/config/game.properties` e `/config/user-interface.properties`, sebbene ci siano quattro chiavi nella ConfigMap. Ciò avviene perché la definizione del Pod specifica una lista di `items` nella sezione dei `volumes`. Se ometti del tutto la lista degli `items`, ogni chiave nella ConfigMap diventerà un file con lo stesso nome della chiave, e otterrai 4 files.
Usare le ConfigMaps
-------------------
Le ConfigMaps possono essere montate come volumi. Le ConfigMaps possono anche essere utilizzate da altre parti del sistema, senza essere direttamente esposte al Pod. Per esempio, le ConfigMaps possono contenere l'informazione che altre parti del sistema utilizzeranno per la loro configurazione.
La maniera più comune per usare le ConfigMaps è di configurare i containers che sono in esecuzione in un Pod nello stesso namespace. Puoi anche utilizzare una ConfigMap separatamente.
Per esempio, potresti incontrare [addons](https://kubernetes.io/it/docs/concepts/cluster-administration/addons/ "Resources that extend the functionality of Kubernetes.")
o [operators](https://kubernetes.io/it/docs/concepts/extend-kubernetes/operator/ "A specialized controller used to manage a custom resource")
che adattano il loro comportamento in base a una ConfigMap.
### Usare le ConfigMaps come files in un Pod
Per utilizzare una ConfigMap in un volume all'interno di un Pod:
1. Creare una ConfigMap o usarne una che già esiste. Più Pods possono utilizzare la stessa ConfigMap.
2. Modificare la definizione del Pod per aggiungere un volume sotto `.spec.volumes[]`. Nominare il volume in qualsiasi modo, e avere un campo `.spec.volumes[].configMap.name` configurato per referenziare il tuo oggetto ConfigMap.
3. Aggiungere un `.spec.containers[].volumeMounts[]` a ogni container che necessiti di una ConfigMap. Nello specifico `.spec.containers[].volumeMounts[].readOnly = true` e `.spec.containers[].volumeMounts[].mountPath` in una cartella inutilizzata dove vorresti che apparisse la ConfigMap.
4. Modificare l'immagine o il comando utilizzato così che il programma cerchi i files in quella cartella. Ogni chiave nella sezione `data` della ConfigMap si converte in un file sotto `mountPath`.
Questo è un esempio di un Pod che monta una ConfigMap in un volume:
apiVersion: v1
kind: Pod
metadata:
name: mypod
spec:
containers:
- name: mypod
image: redis
volumeMounts:
- name: foo
mountPath: "/etc/foo"
readOnly: true
volumes:
- name: foo
configMap:
name: myconfigmap
Ogni ConfigMap che desideri utilizzare deve essere referenziata in `.spec.volumes`.
Se c'è più di un container nel Pod, allora ogni container necessita del suo blocco `volumeMounts`, ma solamente un `.spec.volumes` è necessario ConfigMap.
#### Le ConfigMaps montate sono aggiornate automaticamente
Quando una ConfigMap è utilizzata in un volume ed è aggiornata, anche le chiavi vengono aggiornate. Il kubelet controlla se la ConfigMap montata è aggiornata ad ogni periodo di sincronizzazione. Ad ogni modo, il kubelet usa la sua cache locale per ottenere il valore attuale della ConfigMap. Il tipo di cache è configurabile usando il campo `ConfigMapAndSecretChangeDetectionStrategy` nel [KubeletConfiguration struct](https://kubernetes.io/docs/reference/config-api/kubelet-config.v1beta1/)
. Una ConfigMap può essere propagata per vista (default), ttl-based, o redirigendo tutte le richieste direttamente all'API server. Come risultato, il ritardo totale dal momento in cui la ConfigMap è aggiornata al momento in cui nuove chiavi sono propagate al Pod può essere tanto lungo quanto il periodo della sincronizzazione del kubelet + il ritardo della propagazione della cache, dove il ritardo della propagazione della cache dipende dal tipo di cache scelta (è uguale rispettivamente al ritardo della propagazione, ttl della cache, o zero).
Le ConfigMaps consumate come variabili d'ambiente non sono aggiornate automaticamente e necessitano di un riavvio del pod.
#### Nota:
Un container utilizzando una ConfigMap come un [subPath](https://kubernetes.io/docs/concepts/storage/volumes#using-subpath)
volume mount non riceverà gli aggiornamenti della ConfigMap.
ConfigMaps Immutabili
---------------------
FEATURE STATE: `Kubernetes v1.21 [stable]`
La funzionalità di Kubernetes _Immutable Secrets and ConfigMaps_ fornisce un'opzione per configurare Secrets individuali e ConfigMaps come immutabili. Per clusters che usano le ConfigMaps come estensione (almeno decine o centinaia di ConfigMap uniche montate nel Pod), prevenire i cambiamenti nei loro dati ha i seguenti vantaggi:
* protezione da aggiornamenti accidentali (o non voluti) che potrebbero causare l'interruzione di applicazioni
* miglioramento della performance del tuo cluster riducendo significativamente il carico sul kube-apiserver, chiudendo l'ascolto sulle ConfigMaps che sono segnate come immutabili.
Questa funzionalità è controllata dal `ImmutableEphemeralVolumes` [feature gate](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/)
. Puoi creare una ConfigMap immutabile settando il campo `immutable` a `true`. Per esempio:
apiVersion: v1
kind: ConfigMap
metadata:
...
data:
...
immutable: true
Una volta che una ConfigMap è segnata come immutabile, _non_ è possibile invertire questo cambiamento né cambiare il contenuto del campo `data` o `binaryData` field. Puoi solamente cancellare e ricreare la ConfigMap. Poiché i Pods hanno un puntamento verso la ConfigMap eliminata, è raccomandato di ricreare quei Pods.
Voci correlate
--------------
* Leggi in merito [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)
.
* Leggi [Configura un Pod per utilizzare una ConfigMap](https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/)
.
* Leggi in merito [Modificare una ConfigMap (o qualsiasi altro oggetto di Kubernetes)](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/update-api-object-kubectl-patch/)
* Leggi [The Twelve-Factor App](https://12factor.net/)
per comprendere il motivo di separare il codice dalla configurazione.
3.5 - Amministrazione del Cluster
=================================
3.5.1 - Proxy in Kubernetes
===========================
Questa pagina spiega i proxy utilizzati con Kubernetes.
Proxy
-----
Esistono diversi proxy che puoi incontrare quando usi Kubernetes:
1. Il [kubectl proxy](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#direct-accessing-the-rest-api)
:
- viene eseguito sul computer di un utente o in un pod - collega un localhost address all'apiserver di Kubernetes - il client comunica con il proxy in HTTP - il proxy comunica con l'apiserver in HTTPS - individua l'apiserver - aggiunge gli header di autenticazione
1. L'[apiserver proxy](https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster-services/#discovering-builtin-services)
:
- è un proxy presente nell'apiserver - collega un utente al di fuori del cluster agli IP del cluster che altrimenti potrebbero non essere raggiungibili - è uno dei processi dell'apiserver - il client comunica con il proxy in HTTPS (o HTTP se l'apiserver è configurato in tal modo) - il proxy comunica con il target via HTTP o HTTPS come scelto dal proxy utilizzando le informazioni disponibili - può essere utilizzato per raggiungere un nodo, un pod o un servizio - esegue il bilanciamento del carico quando viene utilizzato per raggiungere un servizio
1. Il [kube proxy](https://kubernetes.io/docs/concepts/services-networking/service/#ips-and-vips)
:
- è eseguito su ciascun nodo - fa da proxy per comunicazioni UDP, TCP e SCTP - non gestisce il protocollo HTTP - esegue il bilanciamento del carico - è usato solo per raggiungere i servizi
1. Un proxy/bilanciatore di carico di fronte agli apiserver:
- la sua esistenza e implementazione variano da cluster a cluster (ad esempio nginx) - si trova tra i client e uno o più apiserver - funge da bilanciatore di carico se ci sono più di un apiserver.
1. Cloud Load Balancer su servizi esterni:
- sono forniti da alcuni fornitori di servizi cloud (ad es. AWS ELB, Google Cloud Load Balancer) - vengono creati automaticamente quando il servizio Kubernetes ha tipo `LoadBalancer` - solitamente supporta solo UDP / TCP - il supporto SCTP dipende dall'implementazione del bilanciatore di carico del provider cloud - l'implementazione varia a seconda del provider cloud.
Gli utenti di Kubernetes in genere non devono preoccuparsi alcun proxy, se non i primi due tipi. L'amministratore del cluster in genere assicurerà che gli altri tipi di proxy siano impostati correttamente.
Richiedere reindirizzamenti
---------------------------
I proxy hanno sostituito le funzioni di reindirizzamento. I reindirizzamenti sono stati deprecati.
3.6 - Esempio di modello di concetto
====================================
#### Nota:
Assicurati anche di [creare una voce nel sommario](https://kubernetes.io/docs/home/contribute/write-new-topic/#creating-an-entry-in-the-table-of-contents)
per il tuo nuovo documento.
Questa pagina spiega ...
Comprendendo ...
----------------
Kubernetes fornisce ...
Usando ...
----------
Usare
Voci correlate
--------------
**\[Sezione opzionale\]**
* Ulteriori informazioni su [Scrivere un nuovo argomento](https://kubernetes.io/docs/home/contribuisci/scrivi-nuovo-argomento/)
.
* Vedi [Uso dei modelli di pagina - Modello di concetto](https://kubernetes.io/docs/home/contribuis/page-templates/#concept_template)
su come utilizzare questo modello.
4 - Tutorials
=============
Questa sezione della documentazione di Kubernetes contiene i tutorials. Un tutorial mostra come raggiungere un obiettivo più complesso di un singolo [task](https://kubernetes.io/docs/tasks/)
. Solitamente un tutorial ha diverse sezioni, ognuna delle quali consiste in una sequenza di più task. Prima di procedere con vari tutorial, raccomandiamo di aggiungere il [Glossario](https://kubernetes.io/it/docs/reference/glossary/)
ai tuoi bookmark per riferimenti successivi.
Per cominciare
--------------
* [Kubernetes Basics](https://kubernetes.io/docs/tutorials/kubernetes-basics/)
è un approfondito tutorial che aiuta a capire cosa è Kubernetes e che permette di testare in modo interattivo alcune semplici funzionalità di Kubernetes.
* [Introduction to Kubernetes (edX)](https://www.edx.org/course/introduction-kubernetes-linuxfoundationx-lfs158x)
* [Hello Minikube](https://kubernetes.io/it/docs/tutorials/hello-minikube/)
Configurazione
--------------
* [Configurare Redis utilizzando una ConfigMap](https://kubernetes.io/docs/tutorials/configuration/configure-redis-using-configmap/)
Stateless Applications
----------------------
* [Esporre un External IP Address per permettere l'accesso alle applicazioni nel Cluster](https://kubernetes.io/docs/tutorials/stateless-application/expose-external-ip-address/)
* [Esempio: Rilasciare l'applicazione PHP Guestbook con Redis](https://kubernetes.io/docs/tutorials/stateless-application/guestbook/)
Stateful Applications
---------------------
* [StatefulSet Basics](https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/)
* [Esempio: WordPress e MySQL con i PersistentVolumes](https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/)
* [Esempio: Rilasciare Cassandra con i StatefulSets](https://kubernetes.io/docs/tutorials/stateful-application/cassandra/)
* [Eseguire ZooKeeper, un sistema distribuito CP](https://kubernetes.io/docs/tutorials/stateful-application/zookeeper/)
Clusters
--------
* [AppArmor](https://kubernetes.io/docs/tutorials/clusters/apparmor/)
* [Seccomp](https://kubernetes.io/docs/tutorials/clusters/seccomp/)
Servizi
-------
* [Utilizzare Source IP](https://kubernetes.io/docs/tutorials/services/source-ip/)
Voci correlate
--------------
Se sei interessato a scrivere un tutorial, vedi [Utilizzare i Page Templates](https://kubernetes.io/docs/home/contribute/page-templates/)
per informazioni su come creare una tutorial page e sul tutorial template.
4.1 - Hello Minikube
====================
Questo tutorial mostra come eseguire una semplice applicazione in Kubernetes utilizzando [Minikube](https://kubernetes.io/docs/setup/learning-environment/minikube)
e Katacoda. Katacoda permette di operare su un'installazione di Kubernetes dal tuo browser.
#### Nota:
Come alternativa, è possibile eseguire questo tutorial [installando minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/)
localmente.
Obbiettivi
----------
* Rilasciare una semplice applicazione su Minikube.
* Eseguire l'applicazione.
* Visualizzare i log dell'applicazione.
Prima di cominciare
-------------------
Questo tutorial fornisce una container image che utilizza NGINX per risponde a tutte le richieste con un echo che visualizza i dati della richiesta stessa.
Crea un Minikube cluster
------------------------
1. Click **Launch Terminal**
#### Nota:
Se hai installato Minikube localmente, esegui `minikube start`.
2. Apri la console di Kubernetes nel browser:
minikube dashboard
3. Katacoda environment only: In alto alla finestra del terminale, fai click segno più, e a seguire click su **Select port to view on Host 1**.
4. Katacoda environment only: Inserisci `30000`, a seguire click su **Display Port**.
Crea un Deployment
------------------
Un Kubernetes [_Pod_](https://kubernetes.io/docs/concepts/workloads/pods/pod/)
è un gruppo di uno o più Containers, che sono uniti tra loro dal punto di vista amministrativo e che condividono lo stesso network.
Il Pod in questo tutorial ha un solo Container. Un Kubernetes [_Deployment_](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
monitora lo stato del Pod ed eventualmente provvedere a farlo ripartire nel caso questo termini. L'uso dei Deployments è la modalità raccomandata per gestire la creazione e lo scaling dei Pods.
1. Usa il comando `kubectl create` per creare un Deployment che gestisce un singolo Pod. Il Pod eseguirà un Container basato sulla Docker image specificata.
kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.53 -- /agnhost netexec --http-port=8080
2. Visualizza il Deployment:
kubectl get deployments
L'output del comando è simile a:
NAME READY UP-TO-DATE AVAILABLE AGE
hello-node 1/1 1 1 1m
3. Visualizza il Pod creato dal Deployment:
kubectl get pods
L'output del comando è simile a:
NAME READY STATUS RESTARTS AGE
hello-node-5f76cf6ccf-br9b5 1/1 Running 0 1m
4. Visualizza gli eventi del cluster Kubernetes:
kubectl get events
5. Visualizza la configurazione di `kubectl`:
kubectl config view
#### Nota:
Per maggiori informazioni sui comandi di `kubectl`, vedi [kubectl overview](https://kubernetes.io/docs/user-guide/kubectl-overview/)
.
Crea un Service
---------------
Con le impostazioni di default, un Pod è accessibile solamente dagli indirizzi IP interni al Kubernetes cluster. Per far si che il Container `hello-node` sia accessibile dall'esterno del Kubernetes virtual network, è necessario esporre il Pod utilizzando un Kubernetes [_Service_](https://kubernetes.io/docs/concepts/services-networking/service/)
.
1. Esponi il Pod su internet untilizzando il comando `kubectl expose`:
kubectl expose deployment hello-node --type=LoadBalancer --port=8080
Il flag `--type=LoadBalancer` indica la volontà di esporre il Service all'esterno del Kubernetes cluster.
2. Visualizza il Servizio appena creato:
kubectl get services
L'output del comando è simile a:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hello-node LoadBalancer 10.108.144.78 8080:30369/TCP 21s
kubernetes ClusterIP 10.96.0.1 443/TCP 23m
Nei cloud providers che supportano i servizi di tipo load balancers, viene fornito un indirizzo IP pubblico per permettere l'acesso al Service. Su Minikube, il service type `LoadBalancer` rende il Service accessibile attraverso il comando `minikube service`.
3. Esegui il comando:
minikube service hello-node
4. Katacoda environment only: Fai click segno più, e a seguire click su **Select port to view on Host 1**.
5. Katacoda environment only: Fai attenzione al numero di 5 cifre visualizzato a fianco di `8080` nell'output del comando. Questo port number è generato casualmente e può essere diverso nel tuo caso. Inserisci il tuo port number nella textbox, e a seguire fai click su Display Port. Nell'esempio precedente, avresti scritto `30369`.
Questo apre un finestra nel browser dove l'applicazione visuallizza l'echo delle richieste ricevute.
Attiva gli addons
-----------------
Minikube include un set [addons](https://kubernetes.io/it/docs/concepts/cluster-administration/addons/ "Resources that extend the functionality of Kubernetes.")
che possono essere attivati, disattivati o eseguti nel ambiente Kubernetes locale.
1. Elenca gli addons disponibili:
minikube addons list
L'output del comando è simile a:
addon-manager: enabled
dashboard: enabled
default-storageclass: enabled
efk: disabled
freshpod: disabled
gvisor: disabled
helm-tiller: disabled
ingress: disabled
ingress-dns: disabled
logviewer: disabled
metrics-server: disabled
nvidia-driver-installer: disabled
nvidia-gpu-device-plugin: disabled
registry: disabled
registry-creds: disabled
storage-provisioner: enabled
storage-provisioner-gluster: disabled
2. Attiva un addon, per esempio, `metrics-server`:
minikube addons enable metrics-server
L'output del comando è simile a:
metrics-server was successfully enabled
3. Visualizza i Pods ed i Service creati in precedenza:
kubectl get pod,svc -n kube-system
L'output del comando è simile a:
NAME READY STATUS RESTARTS AGE
pod/coredns-5644d7b6d9-mh9ll 1/1 Running 0 34m
pod/coredns-5644d7b6d9-pqd2t 1/1 Running 0 34m
pod/metrics-server-67fb648c5 1/1 Running 0 26s
pod/etcd-minikube 1/1 Running 0 34m
pod/influxdb-grafana-b29w8 2/2 Running 0 26s
pod/kube-addon-manager-minikube 1/1 Running 0 34m
pod/kube-apiserver-minikube 1/1 Running 0 34m
pod/kube-controller-manager-minikube 1/1 Running 0 34m
pod/kube-proxy-rnlps 1/1 Running 0 34m
pod/kube-scheduler-minikube 1/1 Running 0 34m
pod/storage-provisioner 1/1 Running 0 34m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/metrics-server ClusterIP 10.96.241.45 80/TCP 26s
service/kube-dns ClusterIP 10.96.0.10 53/UDP,53/TCP 34m
service/monitoring-grafana NodePort 10.99.24.54 80:30002/TCP 26s
service/monitoring-influxdb ClusterIP 10.111.169.94 8083/TCP,8086/TCP 26s
4. Disabilita `metrics-server`:
minikube addons disable metrics-server
L'output del comando è simile a:
metrics-server was successfully disabled
Clean up
--------
Adesso puoi procedere a fare clean up delle risorse che hai creato nel tuo cluster:
kubectl delete service hello-node
kubectl delete deployment hello-node
Eventualmente, puoi stoppare la Minikube virtual machine (VM):
minikube stop
Eventualmente, puoi cancellare la Minikube VM:
minikube delete
Voci correlate
--------------
* Approfondisci la tua conoscenza dei [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
.
* Approfondisci la tua conoscenza di [Rilasciare applicazioni](https://kubernetes.io/docs/tasks/run-application/run-stateless-application-deployment/)
.
* Approfondisci la tua conoscenza dei [Services](https://kubernetes.io/docs/concepts/services-networking/service/)
.
---
# शेडुलिंग | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/reference/scheduling/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/reference/scheduling/)
.
शेडुलिंग
========
---
# Współtworzenie nowych treści | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/contribute/new-content/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/contribute/new-content/)
.
Współtworzenie nowych treści
============================
* 1: [Dokumentowanie funkcji nowego wydania](https://kubernetes.io/pl/docs/contribute/new-content/_print/#pg-10ed45584b496b99003f299b4614ff78)
Ta sekcja zawiera informacje, które powinieneś znać przed dodaniem nowej treści.
Istnieją również dedykowane strony dotyczące pisania [studiów przypadków](https://kubernetes.io/docs/contribute/new-content/case-studies)
oraz [artykułów na bloga](https://kubernetes.io/docs/contribute/blog/)
.
Proces tworzenia nowej treści
-----------------------------
flowchart LR subgraph second\[Zanim zaczniesz\] direction TB S\[ \] -.- A\[Podpisz CNCF CLA\] --> B\[Wybierz gałąź Git\] B --> C\[Jeden język na PR\] C --> F\[Sprawdź \
narzędzia dla współtwórców\] end subgraph first\[Podstawy współtworzenia\] direction TB T\[ \] -.- D\[Pisz dokumentację w Markdown \
i buduj stronę za pomocą Hugo\] --- E\[Kod źródłowy w GitHub\] E --- G\[Folder '/content/../docs' zawiera dokumentację \
w wielu językach\] G --- H\[Zapoznaj się z typami stron \
i shortcode'ami w Hugo\] end first ----> second classDef grey fill:#dddddd,stroke:#ffffff,stroke-width:px,color:#000000, font-size:15px; classDef white fill:#ffffff,stroke:#000,stroke-width:px,color:#000,font-weight:bold classDef spacewhite fill:#ffffff,stroke:#fff,stroke-width:0px,color:#000 class A,B,C,D,E,F,G,H grey class S,T spacewhite class first,second white
_**Rysunek - Przygotowanie nowej treści**_
Powyższy rysunek przedstawia informacje, które powinieneś znać przed przesłaniem nowej treści. Szczegóły znajdują się poniżej.
Podstawy kontrybucji
--------------------
* Napisz dokumentację Kubernetesa w formacie Markdown i zbuduj stronę Kubernetesa za pomocą [Hugo](https://gohugo.io/)
.
* Dokumentacja Kubernetesa używa [CommonMark](https://commonmark.org/)
jako swojej wersji Markdown.
* Źródło znajduje się na [GitHub](https://github.com/kubernetes/website)
. Dokumentację Kubernetesa można znaleźć w `/content/en/docs/`. Część dokumentacji referencyjnej jest automatycznie generowana ze skryptów w katalogu `update-imported-docs/`.
* [Typy zawartości strony](https://kubernetes.io/pl/docs/contribute/style/page-content-types/)
opisują sposób prezentacji treści dokumentacji w Hugo.
* Możesz użyć [kodów Docsy](https://www.docsy.dev/docs/adding-content/shortcodes/)
lub [niestandardowych skrótów Hugo](https://kubernetes.io/docs/contribute/style/hugo-shortcodes/)
, aby wspierać dokumentację Kubernetes.
* Oprócz standardowych kodów Hugo, w naszej dokumentacji używamy wielu [niestandardowych kodów Hugo](https://kubernetes.io/docs/contribute/style/hugo-shortcodes/)
, aby kontrolować prezentację treści.
* Dokumentacja jest dostępna w wielu językach w katalogu `/content/`. Każdy język ma własny folder z dwuliterowym kodem określonym przez [standard ISO 639-1](https://www.loc.gov/standards/iso639-2/php/code_list.php)
. Na przykład, źródło dokumentacji angielskiej jest przechowywane w `/content/en/docs/`.
* Aby uzyskać więcej informacji na temat wnoszenia wkładu do dokumentacji w wielu językach lub rozpoczęcia nowego tłumaczenia, zobacz [Lokalizowanie](https://kubernetes.io/pl/docs/contribute/localization/)
.
Zanim zaczniesz
---------------
### Podpisz CNCF CLA
Wszyscy współtwórcy Kubernetesa **muszą** przeczytać [Przewodnik dla Współtwórców](https://github.com/kubernetes/community/blob/master/contributors/guide/README.md)
i [podpisać Umowę Licencyjną Współtwórcy (CLA)](https://github.com/kubernetes/community/blob/master/CLA.md)
.
Pull requesty od autorów, którzy nie podpisali umowy CLA, nie przechodzą testów automatycznych. Imię i adres e-mail, które podasz, muszą zgadzać się z tymi ustawionymi w twoim `git config`, a twoje imię i adres e-mail w git muszą być takie same jak te używane dla CNCF CLA.
### Wybierz gałąź w Git
Podczas otwierania pull requesta musisz wiedzieć z góry, na której gałęzi oprzeć swoją pracę.
| Scenariusz | Gałąź |
| --- | --- |
| Istniejąca lub nowa treść w języku angielskim dla bieżącego wydania | `main` |
| Treść dla wydania zmiany funkcji | Gałąź, która odpowiada głównej i mniejszej wersji, w której znajduje się zmiana funkcji, używając wzorca `dev-`. Na przykład, jeśli funkcja zmienia się w wydaniu `v1.36`, należy dodać zmiany w dokumentacji do gałęzi `dev-1.36`. |
| Treść w innych językach (lokalizacje) | Użyj konwencji danej lokalizacji. Zobacz [Strategia rozgałęzień lokalizacji](https://kubernetes.io/pl/docs/contribute/localization/#branch-strategy) po więcej informacji. |
Jeśli nadal nie masz pewności, którą gałąź wybrać, zapytaj na `#sig-docs` na Slacku.
#### Informacja:
Jeśli już zgłosiłeś swoj pull request i wiesz, że była to niepoprawna gałąź bazowa, możesz ją zmienić (ty i tylko ty, zgłaszający).
### Języki na PR
Ogranicz żądania pull request do jednego języka na PR. Jeśli musisz wprowadzić identyczną zmianę w tym samym fragmencie kodu w wielu językach, otwórz osobne PR dla każdego języka.
Narzędzia dla współtwórców
--------------------------
Katalog [narzędzi dla współtwórców dokumentacji](https://github.com/kubernetes/website/tree/main/content/en/docs/doc-contributor-tools)
w repozytorium `kubernetes/website` zawiera narzędzia, wspierające proces współtworzenia dokumentacji.
Co dalej?
---------
* Przeczytaj jak zgłaszać [artykuły na bloga](https://kubernetes.io/docs/contribute/blog/article-submission/)
.
1 - Dokumentowanie funkcji nowego wydania
=========================================
Każda główna wersja Kubernetesa wprowadza nowe funkcje, które wymagają dokumentacji. Nowe wersje przynoszą również aktualizacje do istniejących funkcji i dokumentacji (na przykład awansowanie funkcji z wersji alpha do beta).
Zazwyczaj SIG odpowiedzialny za funkcję przesyła szkic dokumentacji funkcji jako pull request do odpowiedniego gałęzi rozwojowej w repozytorium `kubernetes/website`, a ktoś z zespołu SIG Docs dostarcza uwagi redakcyjne lub edytuje szkic bezpośrednio. Ta sekcja opisuje konwencje dotyczące rozgałęzień (ang. branching) oraz proces stosowany podczas wydania przez obie grupy.
Więcej o publikowaniu nowych funkcji na blogu przeczytasz w sekcji [komunikaty po wydaniu](https://kubernetes.io/docs/contribute/blog/release-comms/)
.
Dla współtwórców dokumentacji
-----------------------------
Ogólnie rzecz biorąc, współtwórcy dokumentacji nie piszą treści od podstaw na potrzeby wydania. Zamiast tego współpracują z SIG tworzącym nową funkcję, aby dopracować szkic dokumentacji i przygotować go do wydania.
Po wybraniu fukncji do udokumentowania lub wsparcia, zapytaj o nią na kanale Slack `#sig-docs`, podczas cotygodniowego spotkania SIG Docs lub bezpośrednio w zgłoszeniu PR wystawionym przez SIG odpowiedzialny za funkcje. Jeśli otrzymasz zgodę, możesz edytować PR za pomocą jednej z technik opisanych w [Wprowadź zmiany do PR innej osoby](https://kubernetes.io/docs/contribute/review/for-approvers/#commit-into-another-person-s-pr)
.
### Dowiedz się o nadchodzących funkcjach
Aby dowiedzieć się o nadchodzących funkcjach, weź udział w cotygodniowym spotkaniu SIG Release (zobacz stronę [społeczności](https://kubernetes.io/community/)
w celu uzyskania informacji o nadchodzących spotkaniach) i monitoruj dokumentację dotyczącą wydania w repozytorium [kubernetes/sig-release](https://github.com/kubernetes/sig-release/)
. Każde wydanie ma podkatalog w katalogu [/sig-release/tree/master/releases/](https://github.com/kubernetes/sig-release/tree/master/releases)
. Podkatalog zawiera harmonogram wydania, szkic notatek do wydania oraz dokument z listą każdej osoby w zespole wydania.
Harmonogram wersji zawiera linki do wszystkich innych dokumentów, spotkań, protokołów spotkań i kamieni milowych związanych z wydaniem. Zawiera również informacje o celach i harmonogramie wydania oraz wszelkich specjalnych procesach wdrożonych dla tego wydania. Pod koniec dokumentu zdefiniowano kilka terminów związanych z wydaniem.
Ten dokument zawiera również link do **Arkusza śledzenia funkcji**, który jest oficjalnym sposobem na poznanie wszystkich nowych funkcji planowanych do wprowadzenia w wydaniu.
Dokumentacja zespołu odpowiadającego za kolejne wydanie zawiera listę osób do przypisanych do różnych ról. Jeśli nie jest jasne, do kogo się zwrócić w sprawie konkretnej funkcji lub pytania, które masz, możesz skorzystać z jednego z dwóch rozwiązań: weź udział w spotkaniu zespołu, aby zadać swoje pytanie, lub skontaktuj się z liderem wydania, aby mógł Cię odpowiednio skierować.
Szkic notatek z wydania to dobre miejsce, aby dowiedzieć się o specyficznych funkcjach, zmianach, przestarzałych elementach i innych kwestiach dotyczących wydania. Ponieważ treść nie jest ostateczna aż do późnego etapu, warto zachować ostrożność.
### Arkusz śledzenia funkcji
Arkusz śledzenia funkcji [dla danej wersji Kubernetesa](https://github.com/kubernetes/sig-release/tree/master/releases)
wymienia każdą funkcję, która jest planowana do wydania. Każdy element zawiera nazwę funkcji, link do głównego problemu na GitHubie, poziom stabilności (Alpha, Beta lub Stable), SIG i osobę odpowiedzialną za jej wdrożenie, czy wymaga dokumentacji, projekt notatki o wydaniu dla funkcji oraz czy została zintegrowana. Pamiętaj o następujących zasadach:
* Funkcje w wersji Beta i Stable są zazwyczaj priorytetowane wyżej w dokumentacji niż funkcje w wersji Alfa.
* Trudno jest przetestować (a tym samym udokumentować) funkcję, która nie została zmergowana, lub przynajmniej jest uważana za kompletną w swoim PR.
* Określenie, czy funkcja wymaga dokumentacji, jest procesem manualnym. Nawet jeśli funkcja nie jest oznaczona jako wymagająca dokumentacji, może być konieczne jej udokumentowanie.
Dla developerów lub innych członków SIG
---------------------------------------
Ta sekcja zawiera informacje dla członków innych SIG Kubernetesów dokumentujących nowe funkcje na potrzeby wydania.
Jeśli jesteś członkiem SIG, który rozwija nową funkcję dla Kubernetesa, musisz współpracować z SIG Docs, aby mieć pewność, że Twoja funkcja zostanie udokumentowana na czas przed wydaniem. Sprawdź [arkusz śledzenia funkcji](https://github.com/kubernetes/sig-release/tree/master/releases)
lub sprawdź kanał Slack Kubernetes `#sig-release`, aby zweryfikować szczegóły harmonogramu i terminy.
### Otwórz tymczasowy PR
1. Otwórz **szkic** pull requestu do gałęzi `dev-1.36` w repozytorium `kubernetes/website`, z małym commitem, który później zmienisz. Aby utworzyć szkic pull requestu, użyj rozwijanego menu **Create Pull Request** i wybierz **Create Draft Pull Request**, następnie kliknij **Draft Pull Request**.
2. Edytuj opis pull requesta, aby zawierał linki do PR-ów w [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
oraz zgłoszeń w [kubernetes/enhancements](https://github.com/kubernetes/enhancements)
.
3. Zostaw komentarz w powiązanym zgłoszeniu w tym repozytorium [kubernetes/enhancements](https://github.com/kubernetes/enhancements)
z linkiem do PR, aby powiadomić osobę zajmującą się dokumentacją tej wersji, że dokumentacja dotycząca funkcji jest w przygotowaniu i powinna być śledzona w tym wydaniu.
Jeśli Twoja funkcjonalność nie wymaga żadnych zmian w dokumentacji, upewnij się, że zespół sig-release o tym wie, wspominając o tym na kanale Slack `#sig-release`. Jeśli funkcjonalność wymaga dokumentacji, ale PR nie został utworzony, funkcjonalność może zostać usunięta z kamienia milowego.
### PR gotowy do przeglądu
Kiedy będziesz gotowy, wypełnij swój tymczasowy PR dokumentacją funkcji i zmień stan PR z roboczego na **ready for review**. Aby oznaczyć pull request jako gotowy do przeglądu, przejdź do pola scalania (ang. merge box) i kliknij **Ready for review**.
Najlepiej jak potrafisz opisz swoją funkcję i sposób jej użycia. Jeśli potrzebujesz pomocy w strukturyzacji swojej dokumentacji, zapytaj na kanale Slack `#sig-docs`.
Gdy ukończysz swój materiał, osoba odpowiedzialna za dokumentację przypisana do Twojej funkcji go przegląda. Aby zapewnić dokładność techniczną, treść może również wymagać przeglądu technicznego przez odpowiednie SIG-i. Skorzystaj z ich sugestii, aby dopracować treść do stanu gotowego do wydania.
Jeśli twoja funkcja wymaga dokumentacji, a pierwsza wersja treści nie zostanie dostarczona, funkcja może zostać usunięta z kamienia milowego.
#### Bramki funkcji (ang. feature gates)
Jeśli Twoja funkcja jest funkcją Alfa lub Beta i jest włączana warunkowo bramką funkcji (ang. feature gate), potrzebujesz dla niej pliku bramki funkcji wewnątrz `content/en/docs/reference/command-line-tools-reference/feature-gates/`. Nazwa pliku powinna być nazwą bramki funkcji z sufiksem `.md`. Możesz spojrzeć na inne pliki już znajdujące się w tym samym katalogu, aby uzyskać wskazówkę, jak powinien wyglądać Twój plik. Zwykle wystarczy jeden akapit; dla dłuższych wyjaśnień dodaj dokumentację w innym miejscu i dodaj do niej link.
Aby upewnić się, że twój feature gate pojawi się w tabeli [Alpha/Beta Feature gates](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/#feature-gates-for-alpha-or-beta-features)
, dodaj następujące informacje do sekcji [front matter](https://gohugo.io/content-management/front-matter/)
w pliku Markdown z opisem:
stages:
- stage: # Specify the development stage of the feature gate
defaultValue: # Set to true if enabled by default, false otherwise
fromVersion: # Version from which the feature gate is available
toVersion: # (Optional) The version until which the feature gate is available
W przypadku nowych bramek funkcji wymagany jest również osobny opis bramki funkcji; utwórz nowy plik Markdown w `content/en/docs/reference/command-line-tools-reference/feature-gates/` (użyj innych plików jako szablonu).
Gdy zmieniasz bramkę funkcji z domyślnie wyłączonej na domyślnie włączoną, może być konieczne zmienienie również innej dokumentacji (nie tylko listy bramek funkcji). Uważaj na zwroty takie jak „Pole `exampleSetting` jest polem beta i jest domyślnie wyłączone. Możesz je włączyć, włączając bramkę funkcji `ProcessExampleThings`.”
Jeśli Twoja funkcja osiągnęła status GA lub została oznaczona jako przestarzała, dodaj dodatkowy wpis `stage` w ramach bloku `stages` w pliku opisu. Upewnij się, że etapy Alpha i Beta pozostają nienaruszone. Ten krok przenosi bramkę funkcji z [Feature gates for Alpha/Beta](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/#feature-gates-for-alpha-or-beta-features)
do [Feature gates for graduated or deprecated features](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/#feature-gates-for-graduated-or-deprecated-features)
. Na przykład:
stages:
- stage: alpha
defaultValue: false
fromVersion: "1.12"
toVersion: "1.12"
- stage: beta
defaultValue: true
fromVersion: "1.13"
# Added a `toVersion` to the previous stage.
toVersion: "1.18"
# Added 'stable' stage block to existing stages.
- stage: stable
defaultValue: true
fromVersion: "1.19"
toVersion: "1.27"
Ostatecznie Kubernetes przestanie w ogóle uwzględniać bramę funkcji. Aby zasygnalizować usunięcie bramy funkcji, uwzględnij `removed: true` w przedniej części odpowiedniego pliku opisu. Wprowadzenie tej zmiany oznacza, że informacje o bramie funkcji przenoszą się z [Skróty funkcji dla ukończonych lub przestarzałych funkcji](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates-removed/#feature-gates-that-are-removed)
do dedykowanej strony zatytułowanej [Skróty funkcji (usunięte)](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates-removed/)
, łącznie z jej opisem.
### Wszystkie PR-y zostały zrecenzowane i są gotowe do scalenia
Jeśli Twój PR nie został jeszcze scalony z gałęzią `dev-1.36` przed terminem wydania, współpracuj z osobą odpowiedzialną za dokumentację i zarządzającą wydaniem, aby dodać go przed terminem. Jeśli Twoja funkcja potrzebuje dokumentacji, a dokumentacja nie jest gotowa, funkcja może zostać usunięta z bieżącego planu (**milestone**).
---
# उपकरण स्थापित करें | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/tasks/tools/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/tasks/tools/)
.
उपकरण स्थापित करें
==================
अपने कंप्यूटर पर कुबेरनेट्स टूल सेटअप करें।
* 1: [Linux पर kubectl इंस्टॉल और सेट अप करें](https://kubernetes.io/hi/docs/tasks/tools/_print/#pg-37b6179f23c8ad977cb9daa6d2da748a)
* 2: [macOS पर kubectl इंस्टॉल और सेटअप करें](https://kubernetes.io/hi/docs/tasks/tools/_print/#pg-961fc70b732cb8df4fd11a3463b6545c)
* 3: [Windows पर kubectl इंस्टॉल और सेटअप करें](https://kubernetes.io/hi/docs/tasks/tools/_print/#pg-2cc93d3011d707aeb6564bab02048f7a)
kubectl
-------
कुबेरनेट्स कमांड-लाइन टूल, [kubectl](https://kubernetes.io/docs/reference/kubectl/kubectl/)
, आपको कुबेरनेट्स क्लस्टर पर कमांड चलाने की अनुमति देता है।
आप एप्लिकेशन को डिप्लॉय करने, क्लस्टर संसाधनों का निरीक्षण और प्रबंधन करने और लॉग देखने के लिए kubectl का उपयोग कर सकते हैं।
kubectl संचालन की पूरी सूची सहित अधिक जानकारी के लिए, देखें [`kubectl` संदर्भ प्रलेखन](https://kubernetes.io/docs/reference/kubectl/)
.
kubectl विभिन्न प्रकार के Linux प्लेटफॉर्म, macOS और Windows पर इंस्टॉल करने योग्य है। नीचे अपना उपयुक्त ऑपरेटिंग सिस्टम खोजें।
* [kubectl Linux पर इंस्टॉल करें](https://kubernetes.io/hi/docs/tasks/tools/install-kubectl-linux)
* [kubectl macOS पर इंस्टॉल करें](https://kubernetes.io/hi/docs/tasks/tools/install-kubectl-macos)
* [kubectl Windows पर इंस्टॉल करें](https://kubernetes.io/hi/docs/tasks/tools/install-kubectl-windows)
kind
----
[`kind`](https://kind.sigs.k8s.io/docs/)
आपको अपने कंप्यूटर पर कुबेरनेट्स चलाने देता है। इस उपकरण के लिए आवश्यक है कि आपके पास [Docker](https://docs.docker.com/get-docker/)
इंस्टॉल और कॉन्फ़िगर किया गया हो।
kind [क्विक स्टार्ट](https://kind.sigs.k8s.io/docs/user/quick-start/)
पृष्ठ आपको दिखाता है कि kind चलाने के लिए आपको क्या करने की आवश्यकता है।
[kind क्विक स्टार्ट गाइड देखें](https://kind.sigs.k8s.io/docs/user/quick-start/)
minikube
--------
`kind` की तरह, [`minikube`](https://minikube.sigs.k8s.io/)
एक उपकरण है जो आपको स्थानीय स्तर पर कुबेरनेट्स चलाने देता है। minikube आपके कंप्यूटर (windows, macOS और linux पीसी सहित) पर सिंगल-नोड कुबेरनेट्स क्लस्टर चलाता है ताकि आप कुबेरनेट्स सीख सकें या डेवलपमेंट कर सकें।
यदि आपका ध्यान उपकरण को इंस्टॉल करने पर है तो आप मुख्य [आरंभ करें!](https://minikube.sigs.k8s.io/docs/start/)
गाइड का अनुसरण कर सकते हैं।
[minikube क्विक स्टार्ट गाइड देखें](https://minikube.sigs.k8s.io/docs/start/)
एक बार जब आपके पास minikube काम कर रहा हो, तो आप इसका उपयोग [नमूना एप्लिकेशन](https://kubernetes.io/hi/docs/tutorials/hello-minikube/)
चलाने के लिए कर सकते हैं।
kubeadm
-------
कुबेरनेट्स क्लस्टर बनाने और प्रबंधित करने के लिए आप [kubeadm](https://kubernetes.io/hi/docs/admin/kubeadm/ "कुबेरनेट्स को जल्दी से इंस्टॉल करने और एक सुरक्षित क्लस्टर स्थापित करने के लिए एक उपकरण।")
टूल का उपयोग कर सकते हैं। यह उपयोगकर्ता के अनुकूल तरीके से न्यूनतम व्यवहार्य, सुरक्षित क्लस्टर बनाने और चलाने के लिए आवश्यक कार्य करता है।
[kubeadm इंस्टॉल](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/)
करना आपको दिखाता है कि kubeadm को कैसे इंस्टॉल किया जाए। एक बार इंस्टॉल होने के बाद, आप इसका उपयोग [क्लस्टर बनाने](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/)
के लिए कर सकते हैं।
[kubeadm इंस्टॉल गाइड देखें](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/)
1 - Linux पर kubectl इंस्टॉल और सेट अप करें
===========================================
शुरू करने से पहले
-----------------
आप kubectl संस्करण का उपयोग करे जो आपके क्लस्टर के एक माइनर संस्करण के भीतर हो। उदाहरण के लिए, v1.35 क्लाइंट v1.34, v1.35 और v1.36 कण्ट्रोल प्लेन के साथ संवाद कर सकते हैं। kubectl के नवीनतम संस्करण का उपयोग करने से अप्रत्याशित मुद्दों से बचने में मदद मिलती है।
Linux पर kubectl इंस्टॉल करें
-----------------------------
Linux पर kubectl संस्थापित करने के लिए निम्नलिखित विधियाँ मौजूद हैं:
* [Linux पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें](https://kubernetes.io/hi/docs/tasks/tools/_print/#install-kubectl-binary-with-curl-on-linux)
* [नेटिव पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें](https://kubernetes.io/hi/docs/tasks/tools/_print/#install-using-native-package-management)
* [अन्य पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें](https://kubernetes.io/hi/docs/tasks/tools/_print/#install-using-other-package-management)
### Linux पर curl के माध्यम से kubectl बाइनरी इंस्टॉल करें
1. कमांड से नवीनतम रिलीज डाउनलोड करें:
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
#### टिप्पणी:
एक विशिष्ट संस्करण डाउनलोड करने के लिए, कमांड के `$(curl -L -s https://dl.k8s.io/release/stable.txt)` हिस्से को विशिष्ट संस्करण से बदलें।
उदाहरण के लिए, लिनक्स पर 1.35.0 संस्करण डाउनलोड करने के लिए, टाइप करें:
curl -LO https://dl.k8s.io/release/v1.35.0/bin/linux/amd64/kubectl
2. बाइनरी को मान्य करें (वैकल्पिक)
kubectl चेकसम फाइल डाउनलोड करें:
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"
चेकसम फ़ाइल से kubectl बाइनरी को मान्य करें:
echo "$( /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF
yum install -y kubectl
### अन्य पैकेज मैनेजमेंट के माध्यम से इंस्टॉल करें
* [Snap](https://kubernetes.io/hi/docs/tasks/tools/_print/#other-kubectl-install-0)
* [Homebrew](https://kubernetes.io/hi/docs/tasks/tools/_print/#other-kubectl-install-1)
यदि आप Ubuntu या किसी अन्य Linux डिस्ट्रीब्यूशन पर हैं जो [snap](https://snapcraft.io/docs/core/install)
पैकेज मैनेजर को सपोर्ट करता है, तो kubectl [snap](https://snapcraft.io/)
एप्लिकेशन के रूप में उपलब्ध है।
snap install kubectl --classic
kubectl version --client
यदि आप Linux पर [Homebrew](https://docs.brew.sh/Homebrew-on-Linux)
पैकेज मैनेजर का उपयोग कर रहे हैं, तो kubectl [इंस्टालेशन](https://docs.brew.sh/Homebrew-on-Linux#install)
के लिए उपलब्ध है।
brew install kubectl
kubectl version --client
kubectl कॉन्फ़िगरेशन सत्यापित करें
----------------------------------
kubectl को कुबेरनेट्स क्लस्टर को खोजने और एक्सेस करने के लिए, उसे [क्यूबकॉन्फिग फाइल](https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/)
(kubeconfig) की आवश्यकता होती है, जो स्वचालित रूप से तब बनता है जब आप [kube-up.sh](https://github.com/kubernetes/kubernetes/blob/master/cluster/kube-up.sh)
का उपयोग करके क्लस्टर बनाते हैं या मिनीक्यूब क्लस्टर को सफलतापूर्वक डिप्लॉय करते हैं। डिफ़ॉल्ट रूप से, kubectl कॉन्फ़िगरेशन `~/.kube/config` पर स्थित होता है।
जाँच करें कि क्लस्टर स्टेट प्राप्त करके kubectl को ठीक से कॉन्फ़िगर किया गया है:
kubectl cluster-info
यदि आपको एक URL प्रतिक्रिया दिखती हैं, तो kubectl आपके क्लस्टर तक पहुँचने के लिए सही ढंग से कॉन्फ़िगर हुआ है।
यदि आपको निम्नलिखित संदेश दिखाई देता है, तो kubectl ठीक से कॉन्फ़िगर नहीं हुआ है या कुबेरनेट्स क्लस्टर से कनेक्ट करने में सक्षम नहीं है।
The connection to the server was refused - did you specify the right host or port?
उदाहरण के लिए, यदि आप अपने लैपटॉप (स्थानीय रूप से) पर कुबेरनेट्स क्लस्टर चलाना चाहते हैं, तो आपको पहले मिनीक्यूब (minikube) जैसे टूल को इंस्टॉल करना होगा और ऊपर बताए गए कमांड को फिर से चलाना होगा।
यदि `kubectl cluster-info` URL प्रतिक्रिया देता है, लेकिन आप अपने क्लस्टर को एक्सेस नहीं कर पा रहें हैं, तो यह जाँचने के लिए कि क्या यह ठीक से कॉन्फ़िगर किया गया है, इस कमांड का उपयोग करें:
kubectl cluster-info dump
वैकल्पिक kubectl कॉन्फ़िगरेशन और प्लगइन्स
-----------------------------------------
### शेल ऑटोकम्प्लेशन सक्षम करें
kubectl Bash और Zsh के लिए ऑटोकम्प्लेशन का सपोर्ट प्रदान करता है, जो आपका काफी समय बचा सकता है।
नीचे Bash और Zsh के लिए ऑटोकम्प्लेशन स्थापित करने की प्रक्रियाएँ हैं।
* [Bash](https://kubernetes.io/hi/docs/tasks/tools/_print/#kubectl-autocompletion-0)
* [Zsh](https://kubernetes.io/hi/docs/tasks/tools/_print/#kubectl-autocompletion-1)
परिचय
-----
Bash के लिए kubectl समापन स्क्रिप्ट `kubectl completion bash` कमांड के साथ उत्पन्न की जा सकती है। आपके शेल में समापन स्क्रिप्ट को सोर्स करने से kubectl ऑटोकम्पलीशन सक्षम हो जाती है।
हालाँकि, समापन की स्क्रिप्ट [**bash-completion**](https://github.com/scop/bash-completion)
पर निर्भर हैं जिसका अर्थ है कि आपको पहले इस सॉफ़्टवेयर को इंस्टॉल करना होगा (आप `type _init_completion` चलाकर परीक्षण कर सकते हैं कि आपने पहले से bash-completion इंस्टॉल की है या नहीं)।
Bash-completion को इंस्टॉल करें
-------------------------------
कई पैकेज मैनेजर द्वारा bash-completion प्रदान की जाती है ([यहाँ](https://github.com/scop/bash-completion#installation)
देखें)। आप इसे `apt-get install bash-completion` या `yum install bash-completion` आदि के साथ इंस्टॉल कर सकते हैं।
यह कमांड `/usr/share/bash-completion/bash_completion` उत्त्पन्न करता है, जो bash-completion की मुख्य स्क्रिप्ट है। आपके पैकेज मैनेजर के आधार पर, आपको इस फाइल को अपनी `~/.bashrc` फाइल में मैन्युअल रूप से सोर्स करना होगा।
यह पता लगाने के लिए, अपना शेल पुनः लोड करें और `type _init_completion` रन करे। यदि कमांड सफल होता है, तो आप पहले से ही तैयार हैं, अन्यथा अपनी `~/.bashrc` फ़ाइल में निम्नलिखित जोड़ें:
source /usr/share/bash-completion/bash_completion
अपना शेल पुनः लोड करें और `type _init_completion` टाइप करके सत्यापित करें कि बैश-कम्पलीशन सही ढंग से इंस्टॉल है।
kubectl ऑटोकम्पलीशन सक्षम करे
-----------------------------
अब आपको यह सुनिश्चित करने की आवश्यकता है कि kubectl समापन स्क्रिप्ट आपके सभी शेल सत्रों (sourced) में प्राप्त हो जाए। आप ऐसा दो तरीकों से कर सकते हैं:
* अपनी `~/.bashrc` फ़ाइल में समापन स्क्रिप्ट सॉर्स करें:
echo 'source <(kubectl completion bash)' >>~/.bashr
* समापन स्क्रिप्ट को `/etc/bash_completion.d` डायरेक्टरी में जोड़ें: `bash kubectl completion bash >/etc/bash_completion.d/kubectl`
यदि आप के पास kubectl के लिए एक अन्य नाम (alias) है, तो आप उस अन्य नाम के साथ काम करने के लिए शेल समापन को बढ़ा सकते हैं:
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -F __start_kubectl k' >>~/.bashrc
#### टिप्पणी:
bash-completion सभी समापन स्क्रिप्ट को `/etc/bash_completion.d` में सोर्स करता है।
दोनों दृष्टिकोण बराबर हैं। आपके शेल को पुनः लोड करने के बाद, Kubectl ऑटोकम्पलीशन कार्य करना शुरू कर देगा।
Zsh के लिए kubectl कम्पलीशन स्क्रिप्ट `kubectl completion zsh` कमांड के साथ उत्पन्न की जा सकती है। आपके शेल में कम्पलीशन स्क्रिप्ट को सोर्स करने से kubectl ऑटो-कम्पलीशन सक्षम हो जाती है।
अपने सभी शेल सत्रों में ऐसा करने के लिए, निम्नलिखित को अपनी `~/.zshrc` फ़ाइल में जोड़ें:
source <(kubectl completion zsh)
यदि आपके पास kubectl के लिए एक उपनाम है, तो आप उस उपनाम के साथ काम करने के लिए शेल कम्पलीशन को बढ़ा सकते हैं:
echo 'alias k=kubectl' >>~/.zshrc
echo 'complete -F __start_kubectl k' >>~/.zshrc
अपने शेल को पुनः लोड करने के बाद, kubectl ऑटो-कम्पलीशन कार्य करना चाहिए।
यदि आपको कोई त्रुटि मिलती है जैसे `complete:13: command not found: compdef`, तो अपनी `~/.zshrc` फ़ाइल की शुरुआत में निम्नलिखित जोड़ें:
autoload -Uz compinit
compinit
### `kubectl convert` प्लगइन इंस्टॉल करें
कुबेरनेट्स कमांड-लाइन टूल `kubectl` के लिए एक प्लगइन, जो आपको विभिन्न API संस्करण के बीच मैनिफ़ेस्ट को बदलने करने की अनुमति देता है। यह विशेष रूप से नए कुबेरनेट्स रिलीज के साथ एक गैर-बहिष्कृत API संस्करण में मैनिफेस्ट को माइग्रेट करने में सहायक हो सकता है। अधिक जानकारी के लिए, [गैर पदावनत एपिस में विस्थापित करें](https://kubernetes.io/docs/reference/using-api/deprecation-guide/#migrate-to-non-deprecated-apis)
पर जाएं।
1. कमांड से नवीनतम रिलीज डाउनलोड करें:
curl -LO https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert
2. बाइनरी को मान्य करें (वैकल्पिक)
kubectl-convert चेकसम फ़ाइल डाउनलोड करें:
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert.sha256"
चेकसम फ़ाइल से kubectl-convert बाइनरी को मान्य करें:
echo "$( was refused - did you specify the right host or port?
उदाहरण के लिए, यदि आप अपने लैपटॉप (स्थानीय रूप से) पर कुबेरनेट्स क्लस्टर चलाना चाहते हैं, तो आपको पहले मिनीक्यूब (minikube) जैसे टूल को इंस्टॉल करना होगा और ऊपर बताए गए कमांड को फिर से चलाना होगा।
यदि `kubectl cluster-info` URL प्रतिक्रिया देता है, लेकिन आप अपने क्लस्टर को एक्सेस नहीं कर पा रहें हैं, तो यह जाँचने के लिए कि क्या यह ठीक से कॉन्फ़िगर किया गया है, इस कमांड का उपयोग करें:
kubectl cluster-info dump
वैकल्पिक Kubectl कॉन्फ़िगरेशन और प्लगइन्स
-----------------------------------------
### शेल ऑटोकम्प्लेशन सक्षम करें
kubectl Bash और Zsh के लिए ऑटोकम्प्लेशन का सपोर्ट प्रदान करता है, जो आपका काफी समय बचा सकता है।
नीचे Bash और Zsh के लिए ऑटोकम्प्लेशन स्थापित करने की प्रक्रियाएँ हैं।
* [Bash](https://kubernetes.io/hi/docs/tasks/tools/_print/#kubectl-autocompletion-0)
* [Zsh](https://kubernetes.io/hi/docs/tasks/tools/_print/#kubectl-autocompletion-1)
### परिचय
Bash के लिए kubectl समापन स्क्रिप्ट `kubectl completion bash` कमांड के साथ उत्पन्न की जा सकती है। आपके शेल में समापन स्क्रिप्ट को सोर्स करने से kubectl ऑटोकम्पलीशन सक्षम हो जाती है।\`\`\`
हालाँकि, समापन की स्क्रिप्ट [**bash-completion**](https://github.com/scop/bash-completion)
पर निर्भर हैं जिसका अर्थ है कि आपको पहले इस सॉफ़्टवेयर को इंस्टॉल करना होगा।
#### चेतावनी:
Bash-completion के लिये दो संस्करण हैं v1 और v2। v1 bash 3.2 के लिये हैं (जो macOS के लिए डिफ़ॉल्ट है), और v2 bash 4.1+ के लिए है।kubectl कम्पलीशन स्क्रिप्ट Bash-completion v1 और Bash 3.2 के साथ ठीक से **काम नहीं करती है**। इसके लिए **Bash-completion v2** और बैश 4.1+ की आवश्यकता है। इसलिए macOS पर kubectl कम्पलीशन को सही तरीके से इस्तेमाल करने के लिए , आपको bash 4.1+ इनस्टॉल और उपयोग करना होगा ([_निर्देश_](https://apple.stackexchange.com/a/292760)
)। निम्नलिखित निर्देश मानते हैं कि आप बैश का उपयोग करते हैं (अर्थात 4.1 का कोई भी बैश संस्करण या इससे नया)।
### अपग्रेड बैश
निम्नलिखित निर्देश मानते हैं कि आप बैश 4.1+ का उपयोग करते हैं। आप अपने बैश के संस्करण को यह चलाकर देख सकते हैं:
echo $BASH_VERSION
यदि यह बहुत पुराना है, तो आप Homebrew का उपयोग करके इसे इनस्टॉल/अपग्रेड कर सकते हैं:
brew install bash
अपने शेल को पुनः लोड करें और सत्यापित करें कि इच्छित संस्करण का उपयोग किया जा रहा है:
echo $BASH_VERSION $SHELL
Homebrew आमतौर पर इसे `/usr/local/bin/bash` पर इनस्टॉल करता है।
### इनस्टॉल bash-completion
#### टिप्पणी:
जैसा कि उल्लेख किया गया है, ये निर्देश मानते हैं कि आप Bash 4.1+ का उपयोग करते हैं, जिसका अर्थ है कि आप bash-completion v2 इनस्टॉल करेंगे (Bash 3.2 और bash-completion v1 पर kubectl पूर्णता काम नहीं करेगी)।
आप `type_init_completion` से सत्यापित कर सकते हैं कि क्या आपके पास bash-completion v2 पहले से इनस्टॉल है। यदि नहीं, तो आप इसे Homebrew से इनस्टॉल कर सकते हैं
brew install bash-completion@2
जैसा कि इस कमांड के आउटपुट में बताया गया है, अपनी `~/.bash_profile` फ़ाइल में निम्नलिखित जोड़ें:
export BASH_COMPLETION_COMPAT_DIR="/usr/local/etc/bash_completion.d"
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . "/usr/local/etc/profile.d/bash_completion.sh"
अपने शेल को पुनः लोड करें और `type_init_completion` से सत्यापित करें कि bash-completion v2 सही ढंग से इनस्टॉल है।
### kubectl ऑटोकम्पलीशन सक्षम करें
अब आपको यह सुनिश्चित करने की आवश्यकता है कि kubectl समापन स्क्रिप्ट आपके सभी शेल सत्रों (sourced) में प्राप्त हो जाए। इसे हासिल करने के कई तरीके हैं:
* अपने कम्पलीशन स्क्रिप्ट को `~/.bash_profile` में सोर्स करें:
echo 'source <(kubectl completion bash)' >>~/.bash_profile
* कम्पलीशन स्क्रिप्ट को `/usr/local/etc/bash_completion.d` डायरेक्टरी में जोड़ें:
kubectl completion bash >/usr/local/etc/bash_completion.d/kubectl
* यदि आपके पास kubectl के लिए एक नाम (alias) है, तो आप उस उपनाम के साथ काम करने के लिए शेल कम्पलीशन को बढ़ा सकते हैं:
echo 'alias k=kubectl' >>~/.bash_profile
echo 'complete -F __start_kubectl k' >>~/.bash_profile
* यदि आपने Homebrew के साथ kubectl इनस्टॉल किया है (जैसा कि यहां बताया गया है), तो kubectl कम्पलीशन स्क्रिप्ट पहले से ही `/usr/local/etc/bash_completion.d/kubectl` में होनी चाहिए। ऐसे में आपको कुछ भी करने की जरूरत नहीं है।
#### टिप्पणी:
bash-completion Homebrew से इनस्टॉल होने पर, सारे फाइल्स को `BASH_COMPLETION_COMPAT_DIR` डायरेक्टरी में सोर्स कर देता है। इसलिए आखरी दो तरीके काम करते हैं।
किसी भी स्थिति में, आपके शेल को पुनः लोड करने के बाद, Kubectl पूर्णता कार्य करना चाहिए।
Zsh के लिए kubectl कम्पलीशन स्क्रिप्ट `kubectl completion zsh` कमांड के साथ उत्पन्न की जा सकती है। आपके शेल में कम्पलीशन स्क्रिप्ट को सोर्स करने से kubectl ऑटो-कम्पलीशन सक्षम हो जाती है।
अपने सभी शेल सत्रों में ऐसा करने के लिए, निम्नलिखित को अपनी `~/.zshrc` फ़ाइल में जोड़ें:
source <(kubectl completion zsh)
यदि आपके पास kubectl के लिए एक उपनाम है, तो आप उस उपनाम के साथ काम करने के लिए शेल कम्पलीशन को बढ़ा सकते हैं:
echo 'alias k=kubectl' >>~/.zshrc
echo 'complete -F __start_kubectl k' >>~/.zshrc
अपने शेल को पुनः लोड करने के बाद, kubectl ऑटो-कम्पलीशन कार्य करना चाहिए।
यदि आपको कोई त्रुटि मिलती है जैसे `complete:13: command not found: compdef`, तो अपनी `~/.zshrc` फ़ाइल की शुरुआत में निम्नलिखित जोड़ें:
autoload -Uz compinit
compinit
### `kubectl convert` प्लगइन इंस्टॉल करें
कुबेरनेट्स कमांड-लाइन टूल `kubectl` के लिए एक प्लगइन, जो आपको विभिन्न API संस्करण के बीच मैनिफ़ेस्ट को बदलने करने की अनुमति देता है। यह विशेष रूप से नए कुबेरनेट्स रिलीज के साथ एक गैर-बहिष्कृत API संस्करण में मैनिफेस्ट को माइग्रेट करने में सहायक हो सकता है। अधिक जानकारी के लिए, [गैर पदावनत एपिस में विस्थापित करें](https://kubernetes.io/docs/reference/using-api/deprecation-guide/#migrate-to-non-deprecated-apis)
पर जाएं।
1. इस कमांड से नवीनतम रिलीज डाउनलोड करें:
* [Intel](https://kubernetes.io/hi/docs/tasks/tools/_print/#download-convert-binary-macos-0)
* [Apple Silicon](https://kubernetes.io/hi/docs/tasks/tools/_print/#download-convert-binary-macos-1)
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl-convert"
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl-convert"
2. बाइनरी को मान्य करें (वैकल्पिक)
kubectl-convert चेकसम फ़ाइल डाउनलोड करें:
* [Intel](https://kubernetes.io/hi/docs/tasks/tools/_print/#download-convert-checksum-macos-0)
* [Apple Silicon](https://kubernetes.io/hi/docs/tasks/tools/_print/#download-convert-checksum-macos-1)
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl-convert.sha256"
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl-convert.sha256"
चेकसम फ़ाइल से kubectl-convert बाइनरी को मान्य करें:
echo "$( was refused - did you specify the right host or port?
उदाहरण के लिए, यदि आप अपने लैपटॉप (स्थानीय रूप से) पर कुबेरनेट्स क्लस्टर चलाना चाहते हैं, तो आपको पहले मिनीक्यूब (minikube) जैसे टूल को इंस्टॉल करना होगा और ऊपर बताए गए कमांड को फिर से चलाना होगा।
यदि `kubectl cluster-info` URL प्रतिक्रिया देता है, लेकिन आप अपने क्लस्टर को एक्सेस नहीं कर पा रहें हैं, तो यह जाँचने के लिए कि क्या यह ठीक से कॉन्फ़िगर किया गया है, इस कमांड का उपयोग करें:
kubectl cluster-info dump
वैकल्पिक kubectl कॉन्फ़िगरेशन और प्लगइन्स
-----------------------------------------
### शेल ऑटोकम्प्लेशन सक्षम करें
kubectl Bash और Zsh के लिए ऑटोकम्प्लेशन का सपोर्ट प्रदान करता है, जो आपको बहुत सारी टाइपिंग बचा सकता है।
नीचे Zsh के लिए ऑटोकम्प्लेशन स्थापित करने की प्रक्रियाएँ हैं, यदि आप इसे Windows पर चला रहे हैं।
Zsh के लिए kubectl कम्पलीशन स्क्रिप्ट `kubectl completion zsh` कमांड के साथ उत्पन्न की जा सकती है। आपके शेल में कम्पलीशन स्क्रिप्ट को सोर्स करने से kubectl ऑटो-कम्पलीशन सक्षम हो जाती है।
अपने सभी शेल सत्रों में ऐसा करने के लिए, निम्नलिखित को अपनी `~/.zshrc` फ़ाइल में जोड़ें:
source <(kubectl completion zsh)
यदि आपके पास kubectl के लिए एक उपनाम है, तो आप उस उपनाम के साथ काम करने के लिए शेल कम्पलीशन को बढ़ा सकते हैं:
echo 'alias k=kubectl' >>~/.zshrc
echo 'complete -F __start_kubectl k' >>~/.zshrc
अपने शेल को पुनः लोड करने के बाद, kubectl ऑटो-कम्पलीशन कार्य करना चाहिए।
यदि आपको कोई त्रुटि मिलती है जैसे `complete:13: command not found: compdef`, तो अपनी `~/.zshrc` फ़ाइल की शुरुआत में निम्नलिखित जोड़ें:
autoload -Uz compinit
compinit
### इंस्टॉल `kubectl convert` प्लगइन
कुबेरनेट्स कमांड-लाइन टूल `kubectl` के लिए एक प्लगइन, जो आपको विभिन्न API संस्करण के बीच मैनिफ़ेस्ट को बदलने करने की अनुमति देता है। यह विशेष रूप से नए कुबेरनेट्स रिलीज के साथ एक गैर-बहिष्कृत API संस्करण में मैनिफेस्ट को माइग्रेट करने में सहायक हो सकता है। अधिक जानकारी के लिए, [गैर पदावनत एपिस में विस्थापित करें](https://kubernetes.io/docs/reference/using-api/deprecation-guide/#migrate-to-non-deprecated-apis)
पर जाएं।
1. इस कमांड से नवीनतम रिलीज डाउनलोड करें:
curl -LO https://dl.k8s.io/release/v1.35.0/bin/windows/amd64/kubectl-convert.exe
2. बाइनरी को मान्य करें (वैकल्पिक)
kubectl-convert चेकसम फ़ाइल डाउनलोड करें:
curl -LO https://dl.k8s.io/v1.35.0/bin/windows/amd64/kubectl-convert.exe.sha256
चेकसम फ़ाइल से kubectl-convert बाइनरी को मान्य करें:
* मैन्युअल रूप से कमांड प्रॉम्प्ट का उपयोग करके `CertUtil` के आउटपुट की तुलना डाउनलोड किये गये चेकसम फ़ाइल से करें:
CertUtil -hashfile kubectl-convert.exe SHA256
type kubectl-convert.exe.sha256
* `True` या `False` परिणाम प्राप्त करने और `-eq` ऑपरेटर का उपयोग करके सत्यापन को ऑटोमेट करने के लिए Powershell का उपयोग करें:
$($(CertUtil -hashfile .\kubectl-convert.exe SHA256)[1] -replace " ", "") -eq $(type .\kubectl-convert.exe.sha256)
3. अपने `PATH` में बाइनरी जोड़ें।
4. सत्यापित करें कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है।
kubectl convert --help
यदि आपको कोई त्रुटि नहीं दिखाई देती है, तो इसका मतलब है कि प्लगइन सफलतापूर्वक इंस्टॉल हो गया है।
आगे क्या है
-----------
* [मिनीक्यूब (Minikube) इंस्टॉल करें](https://minikube.sigs.k8s.io/docs/start/)
* क्लस्टर बनाने के बारे में अधिक जानकारी के लिए [आरंभ करने की मार्गदर्शिका](https://kubernetes.io/hi/docs/setup/)
देखें।
* [अपने एप्लिकेशन को लॉन्च और एक्सपोज़ करने का तरीका जानें।](https://kubernetes.io/docs/tasks/access-application-cluster/service-access-application-cluster/)
* यदि आपको किसी ऐसे क्लस्टर को उपयोग करने की आवश्यकता है जिसे आपने नहीं बनाया है, तो [क्लस्टर एक्सेस दस्तावेज़ साझा करना](https://kubernetes.io/docs/tasks/access-application-cluster/configure-access-multiple-clusters/)
देखें।
* [kubectl संदर्भ प्रलेखन](https://kubernetes.io/docs/reference/kubectl/kubectl/)
पढ़ें।
---
# 404 Page not found | Kubernetes
Were you looking for:
* [Documentation](https://kubernetes.io/docs/home/)
* [Kubernetes Blog](https://kubernetes.io/blog/)
* [Training](https://kubernetes.io/training/)
* [Careers](https://kubernetes.io/careers/)
* [Partners](https://kubernetes.io/partners/)
* [Community](https://kubernetes.io/community/)
---
# Kontenery | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/concepts/containers/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/concepts/containers/)
.
Kontenery
=========
System "pakowania" aplikacji i jej zależności w spójne środowisko uruchomieniowe.
Ta strona omawia kontenery i obrazy kontenerów, a także ich zastosowanie w utrzymaniu systemów i tworzeniu rozwiązań.
Słowo _kontener (ang. container)_ jest wieloznacznym pojęciem. Zawsze, gdy go używasz, sprawdź, czy Twoi odbiorcy stosują tę samą definicję.
Każdy uruchamiany kontener jest powtarzalny; standaryzacja wynikająca z uwzględnienia zależności oznacza, że uzyskujesz to samo zachowanie, gdziekolwiek go uruchomisz.
Kontenery oddzielają aplikacje od infrastruktury hosta. To ułatwia wdrażanie w różnych środowiskach chmurowych lub systemach operacyjnych.
Każdy [węzeł](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)
w klastrze Kubernetesa uruchamia kontenery, które tworzą [Pody](https://kubernetes.io/pl/docs/concepts/workloads/pods/)
przypisane do tego węzła. Kontenery należące do jednego Poda są uruchamiane razem na tym samym węźle w ramach wspólnego harmonogramu.
Obrazy kontenerów[](https://kubernetes.io/pl/docs/concepts/containers/_print/#container-images)
------------------------------------------------------------------------------------------------
[Obraz kontenera](https://kubernetes.io/docs/concepts/containers/images/)
to gotowy do uruchomienia pakiet oprogramowania zawierający wszystko, co jest potrzebne do uruchomienia aplikacji: kod i wszelkie wymagane środowiska uruchomieniowe, biblioteki aplikacji i systemowe, oraz wartości domyślne dla wszelkich niezbędnych ustawień.
Kontenery są przeznaczone do bycia bezstanowymi i [niezmiennymi](https://glossary.cncf.io/immutable-infrastructure/)
: nie powinieneś zmieniać kodu kontenera, który już działa. Jeśli masz aplikację konteneryzowaną i chcesz dokonać zmian, właściwym procesem jest zbudowanie nowego obrazu zawierającego zmiany, a następnie odtworzenie kontenera w celu uruchomienia go z zaktualizowanego obrazu.
Środowiska uruchomieniowe kontenerów[](https://kubernetes.io/pl/docs/concepts/containers/_print/#container-runtimes)
---------------------------------------------------------------------------------------------------------------------
Podstawowy komponent umożliwiający efektywne uruchamianie kontenerów w Kubernetesie. Odpowiada za zarządzanie uruchamianiem i cyklem życia kontenerów w środowisku Kubernetes.
Kubernetes obsługuje różne _container runtimes_: [containerd](https://containerd.io/docs/)
, [CRI-O](https://cri-o.io/#what-is-cri-o)
oraz każdą implementację zgodną z [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)
.
Zazwyczaj możesz pozwolić swojemu klastrowi na wybranie domyślnego środowiska uruchomieniowego kontenera dla Poda. Jeśli musisz używać więcej niż jednego środowiska uruchomieniowego kontenera w swoim klastrze, możesz określić [RuntimeClass](https://kubernetes.io/docs/concepts/containers/runtime-class/)
dla Poda, aby upewnić się, że Kubernetes uruchamia te kontenery przy użyciu konkretnego środowiska uruchomieniowego kontenera.
Możesz również użyć RuntimeClass, aby uruchamiać różne Pody z tym samym środowiskiem uruchomieniowym kontenera, ale z różnymi ustawieniami.
---
# Aktualizacja materiałów źródłowych | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/)
.
Aktualizacja materiałów źródłowych
==================================
* 1: [Wkład w kod źródłowy Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-a5eac5b2b794f16aa703a2fa212d7c39)
* 2: [Generowanie materiałów źródłowych dla polecenia kubectl](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-03de26b330a5cfdb26672f6bc75dcc04)
* 3: [Generowanie materiałów źródłowych dla metryk](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-7cf2686833318bffe2ef1b82e55748e7)
* 4: [Generowanie materiałów źródłowych dla komponentów i narzedzi Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-28fc50a0072b0b2b444aa24e552d2e60)
* 5:[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-eabe0c0c6b0046c51d7fdf5e8450a5b5)
Tematy w tej sekcji opisują, jak aktualizować (czyli ponownie wygenerować) materiały źródłowe (ang. reference documentation) Kubernetesa.
Aby zbudować materiały źródłowe, zapoznaj się z następującym przewodnikiem:
* [Szybki start generowania materiałów źródłowych](https://kubernetes.io/docs/contribute/generate-ref-docs/quickstart/)
1 - Wkład w kod źródłowy Kubernetesa[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-a5eac5b2b794f16aa703a2fa212d7c39)
===============================================================================================================================================
Ta strona pokazuje, jak wnieść wkład do projektu `kubernetes/kubernetes`. Możesz naprawiać błędy znalezione w dokumentacji API Kubernetesa lub w treściach dla komponentów Kubernetesa, takich jak `kubeadm`, `kube-apiserver` i `kube-controller-manager`.
Jeśli zamiast tego chcesz wygenerować ponownie materiały źródłowe dla API Kubernetesa lub komponentów `kube-*` z kodu źródłowego, zapoznaj się z następującymi instrukcjami:
* [Generowanie materiałów źródłowych dla API Kubernetesa](https://kubernetes.io/docs/contribute/generate-ref-docs/kubernetes-api/)
* [Generowanie materiałów źródłowych dla komponentów i narzędzi Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubernetes-components/)
Zanim zaczniesz[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#zanim-zaczniesz)
------------------------------------------------------------------------------------------------------
* Musisz mieć zainstalowane następujące narzędzia:
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
* [Golang](https://go.dev/doc/install)
wersja 1.13+
* [Docker](https://docs.docker.com/engine/installation/)
* [etcd](https://github.com/coreos/etcd/)
* [make](https://www.gnu.org/software/make/)
* [kompilator/linker gcc](https://gcc.gnu.org/)
* Twoja zmienna środowiskowa `GOPATH` musi być ustawiona, a lokalizacja `etcd` musi znajdować się w zmiennej środowiskowej `PATH`.
* Musisz wiedzieć, jak utworzyć pull requesta do repozytorium GitHub. Zwykle obejmuje to utworzenie forka tego repozytorium. Aby uzyskać więcej informacji, zobacz [Tworzenie pull requesta](https://help.github.com/articles/creating-a-pull-request/)
oraz [Standardowy proces fork i pull request w GitHub](https://gist.github.com/Chaser324/ce0505fbed06b947d962)
.
Ogólny zarys[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#the-big-picture)
---------------------------------------------------------------------------------------------------
Materiały źródłowe dla API Kubernetesa oraz komponentów `kube-*`, takich jak `kube-apiserver`, `kube-controller-manager`, są automatycznie generowane z kodu źródłowego w [głównym repozytorium Kubernetes](https://github.com/kubernetes/kubernetes/)
.
Kiedy zauważysz błędy w wygenerowanej dokumentacji, możesz rozważyć stworzenie poprawki, aby naprawić je w projekcie źródłowym.
Sklonuj repozytorium Kubernetesa[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#clone-the-kubernetes-repository)
---------------------------------------------------------------------------------------------------------------------------------------
Jeśli nie posiadasz jeszcze repozytorium kubernetes/kubernetes, pobierz je teraz:
mkdir $GOPATH/src
cd $GOPATH/src
go get github.com/kubernetes/kubernetes
Określ katalog bazowy swojej kopii repozytorium [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
. Na przykład, jeśli wykonywano wcześniejszy krok w celu pobrania tego repozytorium, to twój katalog bazowy to `$GOPATH/src/github.com/kubernetes/kubernetes`. Pozostałe kroki odnoszą się do twojego katalogu bazowego jako ``.
Określ katalog główny swojego klonu repozytorium [kubernetes-sigs/reference-docs](https://github.com/kubernetes-sigs/reference-docs)
. Na przykład, jeśli wykonałeś wcześniejszy krok, aby pobrać repozytorium, twój katalog główny to `$GOPATH/src/github.com/kubernetes-sigs/reference-docs`. Pozostałe kroki odnoszą się do twojego katalogu głównego jako ``.
Edytowanie kodu źródłowego Kubernetesa[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#edit-the-kubernetes-source-code)
---------------------------------------------------------------------------------------------------------------------------------------------
Dokumentacja materiałów źródłowych API Kubernetesa jest automatycznie generowana z specyfikacji OpenAPI, która jest tworzona na podstawie kodu źródłowego Kubernetesa. Jeśli chcesz zmienić dokumentację materiałów źródłowych API, pierwszym krokiem jest zmiana w kodzie źródłowym Kubernetesa.
Dokumentacja dla komponentów `kube-*` jest także generowana z oryginalnego kodu źródłowego. Musisz zmienić kod związany z komponentem, który chcesz naprawić, aby naprawić generowaną dokumentację.
### Wprowadź zmiany do kodu źródłowego w repozytorium głównym[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#make-changes-to-the-upstream-source-code)
#### Informacja:
Poniższe kroki są przykładowe, nie stanowią ogólnej procedury. Szczegóły w Twojej sytuacji będą się różnić.
Oto przykład edytowania komentarza w kodzie źródłowym Kubernetesa.
W swoim lokalnym repozytorium kubernetes/kubernetes, przełącz się na domyślną gałąź i upewnij się, że jest aktualna:
cd
git checkout master
git pull https://github.com/kubernetes/kubernetes master
Przypuśćmy, że ten plik źródłowy w tej domyślnej gałęzi zawiera literówkę "atmost":
[kubernetes/kubernetes/staging/src/k8s.io/api/apps/v1/types.go](https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/api/apps/v1/types.go)
W swoim lokalnym środowisku otwórz plik `types.go` i zmień "atmost" na "at most".
Zweryfikuj, czy zmieniłeś plik:
git status
Wynik pokazuje, że znajdujesz się na gałęzi głównej, a plik źródłowy `types.go` został zmodyfikowany:
On branch master
...
modified: staging/src/k8s.io/api/apps/v1/types.go
### Zatwierdź swój edytowany plik[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#commit-your-edited-file)
Uruchom `git add` i `git commit`, aby zatwierdzić zmiany, które do tej pory wprowadziłeś. W kolejnym kroku wykonasz drugi commit. Ważne jest, aby utrzymać zmiany rozdzielone na dwa commity.
### Generowanie specyfikacji OpenAPI i powiązanych plików[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#generate-the-openapi-spec-and-related-files)
Przejdź do `` i uruchom te skrypty:
./hack/update-codegen.sh
./hack/update-openapi-spec.sh
Uruchom `git status`, aby zobaczyć, co zostało wygenerowane.
On branch master
...
modified: api/openapi-spec/swagger.json
modified: api/openapi-spec/v3/apis__apps__v1_openapi.json
modified: pkg/generated/openapi/zz_generated.openapi.go
modified: staging/src/k8s.io/api/apps/v1/generated.proto
modified: staging/src/k8s.io/api/apps/v1/types_swagger_doc_generated.go
Sprawdź zawartość pliku `api/openapi-spec/swagger.json`, aby upewnić się, że literówka została poprawiona. Na przykład, możesz uruchomić `git diff -a api/openapi-spec/swagger.json`. Jest to ważne, ponieważ `swagger.json` jest wejściem do drugiego etapu procesu generowania materiałów źródłowych.
Uruchom `git add` i `git commit`, aby zatwierdzić swoje zmiany. Teraz masz dwa commity: jeden, który zawiera edytowany plik `types.go`, oraz drugi, który zawiera wygenerowaną specyfikację OpenAPI i powiązane pliki. Zachowaj te dwa commity oddzielnie. To znaczy, nie łącz tych commitów.
Prześlij swoje zmiany jako [pull request](https://help.github.com/articles/creating-a-pull-request/)
do gałęzi master w repozytorium [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
. Monitoruj swój pull request (PR) i odpowiadaj na uwagi recenzentów w miarę potrzeby. Kontynuuj monitorowanie swojego PR, aż zostanie ono scalone.
[PR 57758](https://github.com/kubernetes/kubernetes/pull/57758)
jest przykładem pull requesta, który naprawia literówkę w kodzie źródłowym Kubernetesa.
#### Informacja:
Określenie właściwego pliku źródłowego do zmiany może być skomplikowane. W podanym przykładzie, główny plik źródłowy znajduje się w katalogu `staging` w repozytorium `kubernetes/kubernetes`. Jednak w Twojej sytuacji katalog `staging` może nie być właściwym miejscem do jego znalezienia. Aby uzyskać wskazówki, sprawdź pliki `README` w repozytorium [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes/tree/master/staging)
oraz w powiązanych repozytoriach, takich jak [kubernetes/apiserver](https://github.com/kubernetes/apiserver/blob/master/README.md)
.
### Zrób cherry pick swojego commita do gałęzi wydania[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#cherry-pick-your-commit-into-a-release-branch)
W poprzednim rozdziale edytowałeś plik w głównej gałęzi (master branch) i uruchomiłeś skrypty, aby wygenerować specyfikację OpenAPI oraz powiązane pliki. Następnie przesłałeś swoje zmiany w PR (ang. pull request) do głównej gałęzi repozytorium kubernetes/kubernetes. Teraz załóżmy, że chcesz wprowadzić swoją zmianę także do gałęzi wydania (release branch). Na przykład, załóżmy, że główna gałąź jest używana do opracowywania wersji Kubernetesa 1.35, a Ty chcesz wprowadzić swoją zmianę również do gałęzi release-1.34.
Przypomnij sobie, że twój pull request zawiera dwa commity: jeden dla edycji `types.go` i jeden dla plików wygenerowanych przez skrypty. Następnym krokiem jest zaproponowanie cherry pick twojego pierwszego commita do gałęzi release-1.34. Chodzi o to, aby cherry pickować commit, który edytował `types.go`, ale nie commit, który zawiera wyniki uruchomienia skryptów. Instrukcje znajdziesz w [Propose a Cherry Pick](https://git.k8s.io/community/contributors/devel/sig-release/cherry-picks.md)
.
#### Informacja:
Propozycja cherry pick wymaga posiadania uprawnienia do ustawienia etykiety i kamienia milowego w swoim PR (ang. pull request). Jeśli nie masz tych uprawnień, będziesz musiał współpracować z kimś, kto może ustawić etykietę i kamień milowy za Ciebie.
Kiedy masz w toku swój pull request dla zastosowania cherry picka ze swoim jednym commitem do gałęzi release-1.34, kolejnym krokiem jest uruchomienie tych skryptów w gałęzi release-1.34 w swoim lokalnym środowisku.
./hack/update-codegen.sh
./hack/update-openapi-spec.sh
Teraz dodaj commit do swojego pull requesta związanego z cherry pickiem, który zawiera niedawno wygenerowaną specyfikację OpenAPI i powiązane pliki. Monitoruj swojego pull requesta, aż zostanie scalony z gałęzią release-1.34.
W tym momencie zarówno gałąź master, jak i gałąź release-1.34 mają zaktualizowany plik `types.go` oraz zestaw wygenerowanych plików, które odzwierciedlają zmiany wprowadzone do `types.go`. Należy zauważyć, że wygenerowana specyfikacja OpenAPI i inne wygenerowane pliki w gałęzi release-1.34 niekoniecznie są takie same jak wygenerowane pliki w gałęzi master. Wygenerowane pliki w gałęzi release-1.34 zawierają elementy API wyłącznie z Kubernetesa 1.34. Wygenerowane pliki w gałęzi master mogą zawierać elementy API, które nie znajdują się w 1.34, ale są w trakcie rozwoju dla 1.35.
Generowanie opublikowanych materiałów źródłowych[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#generate-the-published-reference-docs)
-------------------------------------------------------------------------------------------------------------------------------------------------------------
Poprzednia sekcja pokazała, jak edytować plik źródłowy, a następnie generować kilka plików, w tym `api/openapi-spec/swagger.json` w repozytorium `kubernetes/kubernetes`. Plik `swagger.json` to plik definicji OpenAPI używany do generowania materiałów źródłowych API.
Jesteś teraz gotowy do zapoznania się z przewodnikiem [generowania materiałów źródłowych dla API Kubernetesa](https://kubernetes.io/docs/contribute/generate-ref-docs/kubernetes-api/)
, aby wygenerować [opublikowane materiały źródłowe API Kubernetesa](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/)
.
Co dalej?[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#co-dalej)
-----------------------------------------------------------------------------------------
* [Generowanie materiałów źródłowych dla API Kubernetesa](https://kubernetes.io/docs/contribute/generate-ref-docs/kubernetes-api/)
* [Generowanie materiałów źródłowych dla komponentów i narzędzi Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubernetes-components/)
* [Generowanie materiałów źródłowych dla poleceń `kubectl`](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubectl/)
2 - Generowanie materiałów źródłowych dla polecenia kubectl[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-03de26b330a5cfdb26672f6bc75dcc04)
======================================================================================================================================================================
Ta strona pokazuje, jak wygenerować materiały źródłowe polecenia `kubectl`.
#### Informacja:
Ten temat pokazuje, jak wygenerować materiały źródłowe dla [poleceń kubectl](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands)
takich jak [kubectl apply](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply)
i [kubectl taint](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#taint)
. Ten temat nie pokazuje, jak wygenerować stronę materiałów źródłowych opcji [kubectl](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/)
. Aby uzyskać instrukcje dotyczące generowania strony materiałów źródłowych opcji kubectl, zobacz [Generowanie stron materiałów źródłowych dla komponentów i narzędzi Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubernetes-components/)
.
Zanim zaczniesz[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#zanim-zaczniesz)
------------------------------------------------------------------------------------------------------
### Wymagania:[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#requirements)
* Potrzebujesz maszyny z systemem operacyjnym Linux lub macOS.
* Musisz mieć zainstalowane następujące narzędzia:
* [Python](https://www.python.org/downloads/)
w wersji 3.7.x+
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- Dokumentacja opisuje, jak zainstalować i rozpocząć pracę z systemem kontroli wersji `Git`.
* [Golang](https://go.dev/dl/)
wersja 1.13+
* [Pip](https://pypi.org/project/pip/)
używany do instalacji PyYAML
* [PyYAML](https://pyyaml.org/)
w wersji 5.1.2
* [make](https://www.gnu.org/software/make/)
* [gcc compiler/linker](https://gcc.gnu.org/)
* [Docker](https://docs.docker.com/engine/installation/)
(Wymagany tylko do odniesień do poleceń `kubectl`)
* Twoja zmienna środowiskowa `PATH` musi zawierać wymagane narzędzia do budowania, takie jak binaria `Go` i `python`.
* Musisz wiedzieć, jak utworzyć pull requesta do repozytorium na GitHubie. Wymaga to utworzenia własnego forka repozytorium. Aby uzyskać więcej informacji, zobacz [Praca z lokalnej kopii](https://kubernetes.io/docs/contribute/new-content/open-a-pr/#fork-the-repo)
.
Skonfiguruj lokalne repozytoria[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#set-up-the-local-repositories)
------------------------------------------------------------------------------------------------------------------------------------
Utwórz lokalną przestrzeń roboczą i ustaw swoje `GOPATH`:
mkdir -p $HOME/
export GOPATH=$HOME/
Utwórz lokalną kopię następujących repozytoriów:
go get -u github.com/spf13/pflag
go get -u github.com/spf13/cobra
go get -u gopkg.in/yaml.v2
go get -u github.com/kubernetes-sigs/reference-docs
Jeśli nie masz jeszcze repozytorium kubernetes/website, pobierz je teraz:
git clone https://github.com//website $GOPATH/src/github.com//website
Zrób klon repozytorium kubernetes/kubernetes jako k8s.io/kubernetes:
git clone https://github.com/kubernetes/kubernetes $GOPATH/src/k8s.io/kubernetes
Usuń pakiet spf13 z `$GOPATH/src/k8s.io/kubernetes/vendor/github.com`:
rm -rf $GOPATH/src/k8s.io/kubernetes/vendor/github.com/spf13
Repozytorium kubernetes/kubernetes dostarcza kod źródłowy `kubectl` oraz `kustomize`.
* Określ katalog bazowy twojej kopii repozytorium [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
. Na przykład, jeśli postępowałeś zgodnie z poprzednim krokiem, aby pobrać repozytorium, twój katalog bazowy to `$GOPATH/src/k8s.io/kubernetes`. Kolejne kroki odwołują się do twojego katalogu bazowego jako ``.
* Określ katalog bazowy klonu Twojego repozytorium [kubernetes/website](https://github.com/kubernetes/website)
. Na przykład, jeśli wykonałeś poprzedni krok, aby pobrać repozytorium, Twoim katalogiem bazowym jest `$GOPATH/src/github.com//website`. Kolejne kroki odnoszą się do Twojego katalogu bazowego jako ``.
* Określ katalog główny dla Twojej kopii repozytorium [kubernetes-sigs/reference-docs](https://github.com/kubernetes-sigs/reference-docs)
. Na przykład, jeśli postępowałeś zgodnie z poprzednim krokiem, aby uzyskać repozytorium, Twoim katalogiem głównym będzie `$GOPATH/src/github.com/kubernetes-sigs/reference-docs`. Dalsze kroki odnoszą się do Twojego katalogu głównego jako ``.
W swoim lokalnym repozytorium k8s.io/kubernetes przejdź do interesującej Cię gałęzi i upewnij się, że jest ona aktualna. Na przykład, jeśli chcesz wygenerować dokumentację dla Kubernetesa 1.34.0, możesz użyć tych poleceń:
cd
git checkout v1.34.0
git pull https://github.com/kubernetes/kubernetes 1.34.0
Jeśli nie musisz edytować kodu źródłowego `kubectl`, postępuj zgodnie z instrukcjami dotyczącymi [Ustawiania zmiennych kompilacji](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#set-build-variables)
.
Edytowanie kodu źródłowego kubectl[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#edit-the-kubectl-source-code)
--------------------------------------------------------------------------------------------------------------------------------------
Materiały źródłowe polecenia kubectl są automatycznie generowana z kodu źródłowego kubectl. Jeśli chcesz zmienić materiały źródłowe, pierwszym krokiem jest zmiana jednego lub więcej komentarzy w kodzie źródłowym kubectl. Wprowadź zmianę w swoim lokalnym repozytorium kubernetes/kubernetes, a następnie zgłoś pull requesta do gałęzi master na [github.com/kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
.
[PR 56673](https://github.com/kubernetes/kubernetes/pull/56673/files)
jest przykładem pull requesta, który poprawia literówkę w kodzie źródłowym kubectl.
Monitoruj swój pull request (PR) i odpowiadaj na komentarze recenzentów. Kontynuuj monitorowanie swojego PR, aż zostanie scalony z docelową gałęzią w repozytorium kubernetes/kubernetes.
Zrób cherry pick do gałęzi wydania[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#cherry-pick-your-change-into-a-release-branch)
-------------------------------------------------------------------------------------------------------------------------------------------------------
Twoja zmiana znajduje się teraz w głównej gałęzi, która jest używana do rozwoju następnego wydania Kubernetesa. Jeśli chcesz, aby twoja zmiana pojawiła się w wersji dokumentacji Kubernetesa, która została już wydana, musisz zaproponować włączenie twojej zmiany do gałęzi wydania.
Na przykład, załóżmy, że gałąź master jest używana do rozwijania Kubernetes 1.35 i chcesz przenieść swoją zmianę do gałęzi release-1.34. Aby uzyskać instrukcje, jak to zrobić, zobacz [Proponowanie Cherry Pick](https://git.k8s.io/community/contributors/devel/sig-release/cherry-picks.md)
.
Monitoruj swój cherry pick pull request, aż zostanie scalone z gałęzią wydania.
#### Informacja:
Proponowanie cherry pick wymaga posiadania uprawnień do ustawiania etykiety oraz kamienia milowego w swoim pull requeście. Jeśli nie posiadasz tych uprawnień, będziesz musiał współpracować z kimś, kto może ustawić etykietę i kamień milowy za Ciebie.
Ustaw zmienne budowania[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#set-build-variables)
------------------------------------------------------------------------------------------------------------------
Przejdź do ``. W swoim wierszu poleceń ustaw następujące zmienne środowiskowe.
* Ustaw `K8S_ROOT` na ``.
* Ustaw `K8S_WEBROOT` na ``.
* Ustaw `K8S_RELEASE` na wersję dokumentacji, którą chcesz zbudować. Na przykład, jeśli chcesz zbudować dokumentację dla Kubernetesa 1.34, ustaw `K8S_RELEASE` na 1.34.
Na przykład:
export K8S_WEBROOT=$GOPATH/src/github.com//website
export K8S_ROOT=$GOPATH/src/k8s.io/kubernetes
export K8S_RELEASE=1.34
Tworzenie katalogu wersjonowanego[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#creating-a-versioned-directory)
---------------------------------------------------------------------------------------------------------------------------------------
Uruchomienie budowania (ang. build target) `createversiondirs` tworzy katalog z wersjonowaniem i kopiuje pliki konfiguracyjne kubectl dotyczące materiałów źródłowych do tego katalogu. Nazwa katalogu z wersjonowaniem jest zgodna z wzorcem `v_`.
W katalogu ``, uruchom następujący cel budowania:
cd
make createversiondirs
Sprawdź tag wydania w k8s.io/kubernetes[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#check-out-a-release-tag-in-k8siokubernetes)
---------------------------------------------------------------------------------------------------------------------------------------------------------
W swoim lokalnym repozytorium ``, przejdź do gałęzi, która zawiera wersję Kubernetesa, którą chcesz udokumentować. Na przykład, jeśli chcesz wygenerować dokumentację dla Kubernetesa 1.34.0, przejdź do tagu `v1.34`. Upewnij się, że Twoja lokalna gałąź jest aktualna.
cd
git checkout v1.34.0
git pull https://github.com/kubernetes/kubernetes v1.34.0
Uruchom kod generowania dokumentacji[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#run-the-doc-generation-code)
---------------------------------------------------------------------------------------------------------------------------------------
W lokalnym katalogu ``, uruchom cel budowania (ang. build target) `copycli`. Komenda działa z uprawnieniami `root`:
cd
make copycli
Polecenie `copycli` czyści tymczasowy katalog kompilacji, generuje pliki poleceń kubectl i kopiuje zbiorczą stronę HTML materiałów źródłowych poleceń kubectl oraz zasoby do ``.
Zlokalizuj wygenerowane pliki[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#locate-the-generated-files)
-------------------------------------------------------------------------------------------------------------------------------
Zweryfikuj, czy te dwa pliki zostały wygenerowane:
[ -e "/gen-kubectldocs/generators/build/index.html" ] && echo "index.html built" || echo "no index.html"
[ -e "/gen-kubectldocs/generators/build/navData.js" ] && echo "navData.js built" || echo "no navData.js"
Zlokalizuj skopiowane pliki[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#locate-the-copied-files)
--------------------------------------------------------------------------------------------------------------------------
Zweryfikuj, czy wszystkie wygenerowane pliki zostały skopiowane do Twojego ``:
cd
git status
Wynik powinien zawierać zmodyfikowane pliki:
static/docs/reference/generated/kubectl/kubectl-commands.html
static/docs/reference/generated/kubectl/navData.js
Wynik może również zawierać:
static/docs/reference/generated/kubectl/scroll.js
static/docs/reference/generated/kubectl/stylesheet.css
static/docs/reference/generated/kubectl/tabvisibility.js
static/docs/reference/generated/kubectl/node_modules/bootstrap/dist/css/bootstrap.min.css
static/docs/reference/generated/kubectl/node_modules/highlight.js/styles/default.css
static/docs/reference/generated/kubectl/node_modules/jquery.scrollto/jquery.scrollTo.min.js
static/docs/reference/generated/kubectl/node_modules/jquery/dist/jquery.min.js
static/docs/reference/generated/kubectl/node_modules/font-awesome/css/font-awesome.min.css
Lokalne testowanie dokumentacji[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#locally-test-the-documentation)
-------------------------------------------------------------------------------------------------------------------------------------
Zbuduj dokumentację Kubernetes w lokalnym ``.
cd
git submodule update --init --recursive --depth 1 # if not already done
make container-serve
Zobacz [podgląd lokalny](https://localhost:1313/docs/reference/generated/kubectl/kubectl-commands/)
.
Dodaj i zatwierdź zmiany w kubernetes/website[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#add-and-commit-changes-in-kuberneteswebsite)
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Uruchom `git add` i `git commit`, aby zatwierdzić pliki.
Utwórz pull requesta[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#create-a-pull-request)
-----------------------------------------------------------------------------------------------------------------
Utwórz pull requesta do repozytorium `kubernetes/website`. Monitoruj swój pull request i odpowiadaj na komentarze z przeglądu. Kontynuuj monitorowanie swojego pull requesta aż do momentu jego włączenia do głównej gałęzi kodu.
Kilka minut po włączeniu twojego pull requesta, zaktualizowane tematy materiałów źródłowych będą widoczne w [opublikowanej dokumentacji](https://kubernetes.io/pl/docs/home/)
.
Co dalej?[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#co-dalej)
-----------------------------------------------------------------------------------------
* [Szybki start generowania materiałów źródłowych](https://kubernetes.io/docs/contribute/generate-ref-docs/quickstart/)
* [Generowanie materiałów źródłowych dla komponentów i narzędzi Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubernetes-components/)
* [Generowanie materiałów źródłowych dla Kubernetes API](https://kubernetes.io/docs/contribute/generate-ref-docs/kubernetes-api/)
3 - Generowanie materiałów źródłowych dla metryk[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-7cf2686833318bffe2ef1b82e55748e7)
===========================================================================================================================================================
Ta strona demonstruje generowanie materiałów źródłowych dotyczących metryk.
Zanim zaczniesz[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#zanim-zaczniesz)
------------------------------------------------------------------------------------------------------
### Wymagania:[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#requirements)
* Potrzebujesz maszyny z systemem operacyjnym Linux lub macOS.
* Musisz mieć zainstalowane następujące narzędzia:
* [Python](https://www.python.org/downloads/)
w wersji 3.7.x+
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- Dokumentacja opisuje, jak zainstalować i rozpocząć pracę z systemem kontroli wersji `Git`.
* [Golang](https://go.dev/dl/)
wersja 1.13+
* [Pip](https://pypi.org/project/pip/)
używany do instalacji PyYAML
* [PyYAML](https://pyyaml.org/)
w wersji 5.1.2
* [make](https://www.gnu.org/software/make/)
* [gcc compiler/linker](https://gcc.gnu.org/)
* [Docker](https://docs.docker.com/engine/installation/)
(Wymagany tylko do odniesień do poleceń `kubectl`)
* Twoja zmienna środowiskowa `PATH` musi zawierać wymagane narzędzia do budowania, takie jak binaria `Go` i `python`.
* Musisz wiedzieć, jak utworzyć pull requesta do repozytorium na GitHubie. Wymaga to utworzenia własnego forka repozytorium. Aby uzyskać więcej informacji, zobacz [Praca z lokalnej kopii](https://kubernetes.io/docs/contribute/new-content/open-a-pr/#fork-the-repo)
.
Sklonuj repozytorium Kubernetesa[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#clone-the-kubernetes-repository)
---------------------------------------------------------------------------------------------------------------------------------------
Generowanie metryk odbywa się w repozytorium Kubernetesa. Aby sklonować repozytorium, przejdź do katalogu, w którym chcesz, aby klon istniał.
Następnie wykonaj następujące polecenie:
git clone https://www.github.com/kubernetes/kubernetes
To tworzy folder `kubernetes` w bieżącym katalogu roboczym.
Generowanie metryk[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#generate-the-metrics)
--------------------------------------------------------------------------------------------------------------
W sklonowanym repozytorium Kubernetesa zlokalizuj katalog `test/instrumentation/documentation`. Dokumentacja metryk jest generowana w tym katalogu.
Przy każdej wersji dodawane są nowe metryki. Po uruchomieniu skryptu generatora dokumentacji metryk, skopiuj dokumentację metryk na stronę internetową Kubernetesa i opublikuj zaktualizowaną dokumentację metryk.
Aby wygenerować najnowsze metryki, upewnij się, że znajdujesz się w katalogu głównym sklonowanego katalogu Kubernetesa. Następnie wykonaj następujące polecenie:
./test/instrumentation/update-documentation.sh
Aby sprawdzić zmiany, wykonaj:
git status
Wynik jest podobny do:
./test/instrumentation/documentation/documentation.md
./test/instrumentation/documentation/documentation-list.yaml
Skopiuj wygenerowany plik dokumentacji metryk do repozytorium strony internetowej Kubernetesa[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#copy-the-generated-metrics-documentation-file-to-the-kubernetes-website-repository)
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1. Ustaw zmienną środowiskową głównego katalogu strony Kubernetesa.
Wykonaj następujące polecenie, aby ustawić główny katalog witryny:
export WEBSITE_ROOT=
2. Skopiuj wygenerowany plik metryk do repozytorium witryny Kubernetesa.
cp ./test/instrumentation/documentation/documentation.md "${WEBSITE_ROOT}/content/en/docs/reference/instrumentation/metrics.md"
#### Informacja:
Jeśli pojawi się błąd, sprawdź, czy masz uprawnienia do skopiowania pliku. Możesz użyć `chown`, aby zmienić własność pliku na swojego użytkownika.
Utwórz pull requesta[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#create-a-pull-request)
-----------------------------------------------------------------------------------------------------------------
Aby utworzyć pull request, postępuj zgodnie z instrukcjami w [Otwarcie pull requesta](https://kubernetes.io/docs/contribute/new-content/open-a-pr/)
.
Co dalej?[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#co-dalej)
-----------------------------------------------------------------------------------------
* [Współpraca z głównym projektem](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/contribute-upstream/)
* [Generowanie materiałów źródłowych dla komponentów i narzędzi Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubernetes-components/)
* [Generowanie materiałów źródłowych dla poleceń kubectl](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubectl/)
4 - Generowanie materiałów źródłowych dla komponentów i narzedzi Kubernetesa[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-28fc50a0072b0b2b444aa24e552d2e60)
=======================================================================================================================================================================================
Ta strona pokazuje, jak zbudować strony materiałów źródłowych komponentów i narzędzi Kubernetesa.
Zanim zaczniesz[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#zanim-zaczniesz)
------------------------------------------------------------------------------------------------------
Rozpocznij od sekcji [wymagania wstępne](https://kubernetes.io/docs/contribute/generate-ref-docs/quickstart/#before-you-begin)
w przewodniku "szybki start materiałów źródłowych"
Postępuj zgodnie z [Szybki start](https://kubernetes.io/docs/contribute/generate-ref-docs/quickstart/)
, aby wygenerować strony materiałów źródłowych dla komponentów i narzędzi Kubernetesa.
Co dalej?[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#co-dalej)
-----------------------------------------------------------------------------------------
* [Szybki start](https://kubernetes.io/docs/contribute/generate-ref-docs/quickstart/)
* [Generowanie materiałów źródłowych dla poleceń kubectl](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/kubectl/)
* [Generowanie materiałów źródłowych dla API Kubernetesa](https://kubernetes.io/docs/contribute/generate-ref-docs/kubernetes-api/)
* [Wkład w kod źródłowy Kubernetesa](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/contribute-upstream/)
5 -[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#pg-eabe0c0c6b0046c51d7fdf5e8450a5b5)
==============================================================================================================
### Wymagania:[](https://kubernetes.io/pl/docs/contribute/generate-ref-docs/_print/#requirements)
* Potrzebujesz maszyny z systemem operacyjnym Linux lub macOS.
* Musisz mieć zainstalowane następujące narzędzia:
* [Python](https://www.python.org/downloads/)
w wersji 3.7.x+
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
- Dokumentacja opisuje, jak zainstalować i rozpocząć pracę z systemem kontroli wersji `Git`.
* [Golang](https://go.dev/dl/)
wersja 1.13+
* [Pip](https://pypi.org/project/pip/)
używany do instalacji PyYAML
* [PyYAML](https://pyyaml.org/)
w wersji 5.1.2
* [make](https://www.gnu.org/software/make/)
* [gcc compiler/linker](https://gcc.gnu.org/)
* [Docker](https://docs.docker.com/engine/installation/)
(Wymagany tylko do odniesień do poleceń `kubectl`)
* Twoja zmienna środowiskowa `PATH` musi zawierać wymagane narzędzia do budowania, takie jak binaria `Go` i `python`.
* Musisz wiedzieć, jak utworzyć pull requesta do repozytorium na GitHubie. Wymaga to utworzenia własnego forka repozytorium. Aby uzyskać więcej informacji, zobacz [Praca z lokalnej kopii](https://kubernetes.io/docs/contribute/new-content/open-a-pr/#fork-the-repo)
.
---
# अन्य उपकरण | Kubernetes
This is the multi-page printable view of this section. [Click here to print](https://kubernetes.io/hi/docs/reference/tools/_print/#)
.
[Return to the regular view of this page](https://kubernetes.io/hi/docs/reference/tools/)
.
अन्य उपकरण
==========
कुबेरनेट्स सिस्टम के साथ काम करने में आपकी सहायता के लिए कुबेरनेट्स में कई उपकरण शामिल हैं।
crictl[](https://kubernetes.io/hi/docs/reference/tools/_print/#crictl)
-----------------------------------------------------------------------
[`crictl`](https://github.com/kubernetes-sigs/cri-tools)
[CRI](https://kubernetes.io/hi/docs/concepts/overview/components/#container-runtime)
\-संगत कंटेनर रनटाइम के निरीक्षण और डिबगिंग के लिए एक कमांड-लाइन इंटरफ़ेस है।
Dashboard[](https://kubernetes.io/hi/docs/reference/tools/_print/#dashboard)
-----------------------------------------------------------------------------
कुबेरनेट्स का वेब [`डैशबोर्ड`](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)
आपको क्लस्टर में कंटेनरीकृत अनुप्रयोगों को तैनात करने, उनकी समस्या का निवारण करने और क्लस्टर के संसाधनों को प्रबंधित करने की अनुमति देता है।
Helm[](https://kubernetes.io/hi/docs/reference/tools/_print/#helm)
-------------------------------------------------------------------
🛇 यह वस्तु कोई अन्य पक्ष की परियोजना या उत्पाद से जुड़ा है जो कुबेरनेट्स का हिस्सा नहीं हैं। [अधिक जानकारी के लिए पढ़ें](https://kubernetes.io/hi/docs/reference/tools/_print/#third-party-content-disclaimer)
[हेल्म](https://helm.sh/)
पूर्व-कॉन्फ़िगर कुबेरनेट्स संसाधनों के पैकेजों के प्रबंधन के लिए एक उपकरण है। इन पैकेजों को _हेल्म चार्ट_ के रूप में जाना जाता है।
हेल्म का उपयोग करें:
* कुबेरनेट्स चार्ट के रूप में पैक किए गए लोकप्रिय सॉफ़्टवेयर को ढूंढें और उपयोग करें।
* अपने ख़ुद के एप्लिकेशन को कुबेरनेट्स चार्ट के रूप में साझा करें।
* बुद्धिमत्ता से अपने कुबेरनेट्स मैनिफ़ेस्ट फ़ाइलों को प्रबंधित करें।
* हेल्म पैकेजों के रिलीज़ प्रबंधित करें।
Kompose[](https://kubernetes.io/hi/docs/reference/tools/_print/#kompose)
-------------------------------------------------------------------------
[`कॉम्पोज़`](https://github.com/kubernetes/kompose)
एक उपकरण है, जो डॉकर कंपोज़ उपयोगकर्ताओं को कुबेरनेट्स पर जाने में मदद करता है।
कॉम्पोज़ का उपयोग करें:
* डॉकर कंपोज़ फ़ाइल को कुबेरनेट्स ऑब्जेक्ट्स में अनुवाद करें।
* स्थानीय डॉकर डेवलपमेंट से कुबेरनेट्स एप्लीकेशनों को प्रबंधित करें।
* v1 या v2 डॉकर कंपोज़, `yaml` फ़ाइलों या [डिस्ट्रीब्यूटेड एप्लिकेशनो के बंडलों](https://docs.docker.com/compose/bundles/)
के माध्यम से अपने एप्लिकेशन को प्रबंधित कऱे।
Kui[](https://kubernetes.io/hi/docs/reference/tools/_print/#kui)
-----------------------------------------------------------------
[`Kui`](https://github.com/kubernetes-sigs/kui)
एक GUI उपकरण है, जो आपके सामान्य `kubectl` कमांड लाइन अनुरोधों को लेकर ग्राफिक्स के साथ प्रतिक्रिया देता है।
Kui सामान्य `kubectl` कमांड लाइन अनुरोधों को लेकर ग्राफिक्स के साथ प्रतिक्रिया देता है। ASCII टेबल्स के बजाय, Kui उन टेबल्स के साथ एक GUI प्रदान करता है, जिन्हें आप सॉर्ट कर सकते हैं।
Kui आपको देता है:
* कॉपी और पेस्ट करने के बजाय सीधे लंबे स्वचालित रूप से जेनरेटेड किए गए संसाधनों के नामों पर क्लिक करें।
* `Kubectl` कमांड टाइप करें और उन्हें निष्पादन होते हुए देखें, यहां तक कि कभी-कभी `Kubectl` से भी तेज।
* एक [जॉब](https://kubernetes.io/hi/docs/concepts/workloads/controllers/job/)
क्वेरी करें और इसके निष्पादन को वॉटरफॉल के डायग्राम के रूप में देखें।
* एक टैब्ड UI का उपयोग करके अपने क्लस्टर में संसाधनों पर क्लिक करें।
Minikube[](https://kubernetes.io/hi/docs/reference/tools/_print/#minikube)
---------------------------------------------------------------------------
[`मिनीक्यूब`](https://minikube.sigs.k8s.io/docs/)
एक उपकरण है, जो डेवलपमेंट और परीक्षण जैसे उद्देश्यों के लिए आपके वर्कस्टेशन पर स्थानीय रूप से एक-नोड वाले कुबेरनेट्स क्लस्टर को चलाता है।
---
# Pojęcia | Kubernetes
To wielostronicowy widok tej sekcji do wydrukowania. [Kliknij aby wydrukować](https://kubernetes.io/pl/docs/concepts/_print/#)
.
[Wróć do zwykłego widoku tej strony](https://kubernetes.io/pl/docs/concepts/)
.
Pojęcia
=======
* 1: [Przegląd](https://kubernetes.io/pl/docs/concepts/_print/#pg-0554ac387412eaf4e6e89b2f847dacde)
* 1.1: [Składniki Kubernetesa](https://kubernetes.io/pl/docs/concepts/_print/#pg-13b0f1dbe89228e3d76d2ac231e245f1)
* 1.2: [Objekty w Kubernetesie](https://kubernetes.io/pl/docs/concepts/_print/#pg-110f33530cf761140cb1dab536baef04)
* 1.2.1: [Nazwy i identyfikatory objektów](https://kubernetes.io/pl/docs/concepts/_print/#pg-f37749a83c2916b63279ea60f3cfe53e)
* 1.2.2: [Etykiety i selektory](https://kubernetes.io/pl/docs/concepts/_print/#pg-f1dec4557fb8ffbac9f11390aaaf9fa4)
* 1.2.3: [Przestrzenie nazw (ang. Namespaces)](https://kubernetes.io/pl/docs/concepts/_print/#pg-1127165f472b7181b9c1d5a0b187d620)
* 1.2.4: [Adnotatcje](https://kubernetes.io/pl/docs/concepts/_print/#pg-93cd7a1d4e1623e2bf01afc49a5af69c)
* 1.2.5: [Selektory pól](https://kubernetes.io/pl/docs/concepts/_print/#pg-046c03090d47bc4b89b818dc645c3865)
* 1.2.6: [Zalecane etykiety](https://kubernetes.io/pl/docs/concepts/_print/#pg-5dd62c6a4a481b4cf1ac50f6799eb581)
* 1.3: [API Kubernetesa](https://kubernetes.io/pl/docs/concepts/_print/#pg-0c745f42e623d2b70a53bc0e6db73d95)
* 2: [Architektura klastra](https://kubernetes.io/pl/docs/concepts/_print/#pg-2bf36ccd6b3dbeafecf87c39761b07c7)
* 3: [Kontenery](https://kubernetes.io/pl/docs/concepts/_print/#pg-a5f7383c83ab9eb9cd0e3c4c020b3ae6)
* 4: [Workload](https://kubernetes.io/pl/docs/concepts/_print/#pg-d52aadda80edd9f8c514cfe2321363c2)
* 4.1: [Pod](https://kubernetes.io/pl/docs/concepts/_print/#pg-4d68b0ccf9c683e6368ffdcc40c838d4)
* 4.2: [Zarządzanie Workloadem](https://kubernetes.io/pl/docs/concepts/_print/#pg-89637410cacae45a36ab1cc278c482eb)
* 5: [Usługi, równoważenie obciążenia i sieci w Kubernetesie](https://kubernetes.io/pl/docs/concepts/_print/#pg-0a0a7eca3e302a3c08f8c85e15d337fd)
* 6: [Przechowywanie danych](https://kubernetes.io/pl/docs/concepts/_print/#pg-f018f568c6723865753f150c3c59bdda)
* 7: [Konfiguracja](https://kubernetes.io/pl/docs/concepts/_print/#pg-275bea454e1cf4c5adeca4058b5af988)
* 8: [Bezpieczeństwo](https://kubernetes.io/pl/docs/concepts/_print/#pg-712cb3c03ff14a39e5a83a6d9b71d203)
* 9: [Polityki](https://kubernetes.io/pl/docs/concepts/_print/#pg-ac9161c6d952925b083ad9602b4e8e7f)
* 10: [Harmonogramowanie, pierszeństwo i eksmisja](https://kubernetes.io/pl/docs/concepts/_print/#pg-c21d05f31057c5bcd2ebdd01f4e62a0e)
* 11: [Administracja klastrem](https://kubernetes.io/pl/docs/concepts/_print/#pg-285a3785fd3d20f437c28d87ca4dadca)
* 12: [Windows w Kubernetesie](https://kubernetes.io/pl/docs/concepts/_print/#pg-05a1231ecbfe48ec554e6d078818aca4)
* 13: [Rozszerzanie Kubernetesa](https://kubernetes.io/pl/docs/concepts/_print/#pg-7e0d97616b15e2c383c6a0a96ec442cb)
* 13.1: [Rozszerzanie API Kubernetesa](https://kubernetes.io/pl/docs/concepts/_print/#pg-0af41d3bd7c785621b58b7564793396a)
* 13.2: [Rozszerzenia obliczeniowe, przechowywania danych i sieciowe](https://kubernetes.io/pl/docs/concepts/_print/#pg-c8937cdc9df96f3328becf04f8211292)
Rozdział dotyczący pojęć ma za zadanie pomóc w zrozumieniu poszczególnych składowych systemu oraz obiektów abstrakcyjnych, których Kubernetes używa do reprezentacji [klastra](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-cluster)
, a także posłużyć do lepszego poznania działania całego systemu.
1 - Przegląd[](https://kubernetes.io/pl/docs/concepts/_print/#pg-0554ac387412eaf4e6e89b2f847dacde)
===================================================================================================
Kubernetes to przenośna, rozszerzalna platforma oprogramowania _open source_ służąca do zarządzania zadaniami i serwisami uruchamianymi w kontenerach. Umożliwia ich deklaratywną konfigurację i automatyzację. Kubernetes posiada duży i dynamicznie rozwijający się ekosystem. Szeroko dostępne są usługi, wsparcie i dodatkowe narzędzia.
Na tej stronie znajdziesz ogólne informacje o Kubernetesie.
Nazwa Kubernetes pochodzi z języka greckiego i oznacza sternika albo pilota. Skrót K8s powstał poprzez zastąpienie ośmiu liter pomiędzy "K" i "s". Google otworzyło projekt Kubernetes publicznie w 2014. Kubernetes korzysta z [piętnastoletniego doświadczenia Google w uruchamianiu wielkoskalowych serwisów](https://kubernetes.io/blog/2015/04/borg-predecessor-to-kubernetes/)
i łączy je z najlepszymi pomysłami i praktykami wypracowanymi przez społeczność.
Do czego potrzebujesz Kubernetesa i jakie są jego możliwości[](https://kubernetes.io/pl/docs/concepts/_print/#why-you-need-kubernetes-and-what-can-it-do)
----------------------------------------------------------------------------------------------------------------------------------------------------------
Kontenery są dobrą metodą na opakowywanie i uruchamianie aplikacji. W środowisku produkcyjnym musisz zarządzać kontenerami, w których działają aplikacje i pilnować, aby nie było żadnych przerw w ich dostępności. Przykładowo, kiedy jeden z kontenerów przestaje działać, musi zostać wymieniony. Nie byłoby prościej, aby takimi działaniami zajmował się jakiś system?
I tu właśnie przychodzi z pomocą Kubernetes! Kubernetes zapewnia środowisko do uruchamiania systemów rozproszonych o wysokiej niezawodności. Kubernetes obsługuje skalowanie aplikacji, przełączanie w sytuacjach awaryjnych, różne scenariusze wdrożeń itp. Przykładowo, Kubernetes w łatwy sposób może zarządzać wdrożeniem nowej wersji oprogramowania zgodnie z metodyką _canary deployments_.
Kubernetes zapewnia:
* **Detekcję nowych serwisów i balansowanie ruchu** Kubernetes może udostępnić kontener używając nazwy DNS lub swojego własnego adresu IP. Jeśli ruch przychodzący do kontenera jest duży, Kubernetes może balansować obciążenie i przekierować ruch sieciowy, aby zapewnić stabilność całej instalacji.
* **Zarządzanie obsługą składowania danych** Kubernetes umożliwia automatyczne montowanie systemów składowania danych dowolnego typu - lokalnych, od dostawców chmurowych i innych.
* **Automatyczne wdrożenia i wycofywanie zmian** Możesz opisać oczekiwany stan instalacji za pomocą Kubernetesa, który zajmie się doprowadzeniem w sposób kontrolowany stanu faktycznego do stanu oczekiwanego. Przykładowo, przy pomocy Kubernetesa możesz zautomatyzować proces tworzenia nowych kontenerów na potrzeby swojego wdrożenia, usuwania istniejących i przejęcia zasobów przez nowe kontenery.
* **Automatyczne zarządzanie dostępnymi zasobami** Twoim zadaniem jest dostarczenie klastra maszyn, które Kubernetes może wykorzystać do uruchamiania zadań w kontenerach. Określasz zapotrzebowanie na moc procesora i pamięć RAM dla każdego z kontenerów. Kubernetes rozmieszcza kontenery na maszynach w taki sposób, aby jak najlepiej wykorzystać dostarczone zasoby.
* **Samoczynne naprawianie** Kubernetes restartuje kontenery, które przestały działać, wymienia je na nowe, wymusza wyłączenie kontenerów, które nie odpowiadają na określone zapytania o stan i nie rozgłasza powiadomień o ich dostępności tak długo, dopóki nie są gotowe do działania.
* **Zarządzanie informacjami poufnymi i konfiguracją** Kubernetes pozwala składować i zarządzać informacjami poufnymi, takimi jak hasła, tokeny OAuth czy klucze SSH. Informacje poufne i zawierające konfigurację aplikacji mogą być dostarczane i zmieniane bez konieczności ponownego budowania obrazu kontenerów i bez ujawniania poufnych danych w ogólnej konfiguracji oprogramowania.
* **Wykonywanie wsadowe** Oprócz usług Kubernetes może zarządzać zadaniami wsadowymi i obciążeniami CI, automatycznie wymieniając kontenery, które ulegną awarii.
* **Skalowanie poziome** Skaluj swoją aplikację w górę i w dół za pomocą prostego polecenia, poprzez interfejs użytkownika lub automatycznie na podstawie zużycia CPU.
* **Podwójny stos IPv4/IPv6** Przydzielanie adresów IPv4 i IPv6 do podów i usług
* **Możliwość rozbudowy** Dodawaj funkcje do swojego klastra Kubernetesa bez konieczności zmiany kodu źródłowego w głównym repozytorium.
Czym Kubernetes nie jest[](https://kubernetes.io/pl/docs/concepts/_print/#what-kubernetes-is-not)
--------------------------------------------------------------------------------------------------
Kubernetes nie jest tradycyjnym, zawierającym wszystko systemem PaaS _(Platform as a Service)_. Ponieważ Kubernetes działa w warstwie kontenerów, a nie sprzętu, posiada różne funkcjonalności ogólnego zastosowania, wspólne dla innych rozwiązań PaaS, takie jak: instalacje _(deployments)_, skalowanie i balansowanie ruchu, umożliwiając użytkownikom integrację rozwiązań służących do logowania, monitoringu i ostrzegania. Co ważne, Kubernetes nie jest monolitem i domyślnie dostępne rozwiązania są opcjonalne i działają jako wtyczki. Kubernetes dostarcza elementy, z których może być zbudowana platforma deweloperska, ale pozostawia użytkownikowi wybór i elastyczność tam, gdzie jest to ważne.
Kubernetes:
* Nie ogranicza typów aplikacji, które są obsługiwane. Celem Kubernetesa jest możliwość obsługi bardzo różnorodnego typu zadań, włączając w to aplikacje bezstanowe (_stateless_), aplikacje ze stanem (_stateful_) i ogólne przetwarzanie danych. Jeśli jakaś aplikacja może działać w kontenerze, będzie doskonale sobie radzić w środowisku Kubernetesa.
* Nie oferuje wdrażania aplikacji wprost z kodu źródłowego i nie buduje aplikacji. Procesy Continuous Integration, Delivery, and Deployment (CI/CD) są zależne od kultury pracy organizacji, jej preferencji oraz wymagań technicznych.
* Nie dostarcza serwisów z warstwy aplikacyjnej, takich jak warstwy pośrednie _middleware_ (np. broker wiadomości), środowiska analizy danych (np. Spark), bazy danych (np. MySQL), cache ani klastrowych systemów składowania danych (np. Ceph) jako usług wbudowanych. Te składniki mogą być uruchamiane na klastrze Kubernetes i udostępniane innym aplikacjom przez przenośne rozwiązania, takie jak [Open Service Broker](https://openservicebrokerapi.org/)
.
* Nie wymusza użycia konkretnych systemów zbierania logów, monitorowania ani ostrzegania. Niektóre z tych rozwiązań są udostępnione jako przykłady. Dostępne są też mechanizmy do gromadzenia i eksportowania różnych metryk.
* Nie dostarcza, ani nie wymusza języka/systemu używanego do konfiguracji (np. Jsonnet). Udostępnia API typu deklaratywnego, z którego można korzystać za pomocą różnych metod wykorzystujących deklaratywne specyfikacje.
* Nie zapewnia, ani nie wykorzystuje żadnego ogólnego systemu do zarządzania konfiguracją, utrzymaniem i samo-naprawianiem maszyn.
* Co więcej, nie jest zwykłym systemem planowania _(orchestration)_. W rzeczywistości, eliminuje konieczność orkiestracji. Zgodnie z definicją techniczną, orkiestracja to wykonywanie określonego ciągu zadań: najpierw A, potem B i następnie C. Dla kontrastu, Kubernetes składa się z wielu niezależnych, możliwych do złożenia procesów sterujących, których zadaniem jest doprowadzenie stanu faktycznego do stanu oczekiwanego. Nie ma znaczenia, w jaki sposób przechodzi się od A do C. Nie ma konieczności scentralizowanego zarządzania. Dzięki temu otrzymujemy system, który jest potężniejszy, bardziej odporny i niezawodny i dający więcej możliwości rozbudowy.
Trochę historii[](https://kubernetes.io/pl/docs/concepts/_print/#going-back-in-time)
-------------------------------------------------------------------------------------
Aby zrozumieć, dlaczego Kubernetes stał się taki przydatny, cofnijmy sie trochę w czasie.

**Era wdrożeń tradycyjnych:**
Na początku aplikacje uruchamiane były na fizycznych serwerach. Nie było możliwości separowania zasobów poszczególnych aplikacji, co prowadziło do problemów z alokacją zasobów. Przykładowo, kiedy wiele aplikacji jest uruchomionych na jednym fizycznym serwerze, część tych aplikacji może zużyć większość dostępnych zasobów, powodując spowolnienie działania innych. Rozwiązaniem tego problemu mogło być uruchamianie każdej aplikacji na osobnej maszynie. Niestety, takie podejście ograniczało skalowanie, ponieważ większość zasobów nie była w pełni wykorzystywana, a utrzymanie wielu fizycznych maszyn było kosztowne.
**Era wdrożeń w środowiskach wirtualnych:**
Jako rozwiązanie zaproponowano wirtualizację, która umożliwia uruchamianie wielu maszyn wirtualnych (VM) na jednym procesorze fizycznego serwera. Wirtualizacja pozwala izolować aplikacje pomiędzy maszynami wirtualnymi, zwiększając w ten sposób bezpieczeństwo, jako że informacje związane z jedną aplikacją nie są w łatwy sposób dostępne dla pozostałych.
Wirtualizacja pozwala lepiej wykorzystywać zasoby fizycznego serwera i lepiej skalować, ponieważ aplikacje mogą być łatwo dodawane oraz aktualizowane, pozwala ograniczyć koszty sprzętu oraz ma wiele innych zalet. Za pomocą wirtualizacji można udostępnić wybrane zasoby fizyczne jako klaster maszyn wirtualnych "wielokrotnego użytku".
Każda maszyna wirtualna jest pełną maszyną zawierającą własny system operacyjny pracujący na zwirtualizowanej warstwie sprzętowej.
**Era wdrożeń w kontenerach:**
Kontenery działają w sposób zbliżony do maszyn wirtualnych, ale mają mniejszy stopnień wzajemnej izolacji, współdzieląc ten sam system operacyjny. Kontenery określane są mianem "lekkich". Podobnie, jak maszyna wirtualna, kontener posiada własny system plików, udział w zasobach procesora, pamięć, przestrzeń procesów itd. Ponieważ kontenery są definiowane rozłącznie od leżących poniżej warstw infrastruktury, mogą być łatwiej przenoszone pomiędzy chmurami i różnymi dystrybucjami systemu operacyjnego.
Kontenery zyskały popularność ze względu na swoje zalety, takie jak:
* Szybkość i elastyczność w tworzeniu i instalacji aplikacji: obraz kontenera buduje się łatwiej niż obraz VM.
* Ułatwienie ciągłego rozwoju, integracji oraz wdrażania aplikacji ( _Continuous development, integration, and deployment_): obrazy kontenerów mogą być budowane w sposób wiarygodny i częsty. W razie potrzeby, przywrócenie poprzedniej wersji aplikacji jest stosunkowo łatwie (ponieważ obrazy są niezmienne).
* Rozdzielenie zadań _Dev_ i _Ops_: obrazy kontenerów powstają w fazie _build/release_, a nie w trakcie procesu instalacji, oddzielając w ten sposób aplikacje od infrastruktury.
* Obserwowalność obejmuje nie tylko informacje i metryki z poziomu systemu operacyjnego, ale także poprawność działania samej aplikacji i inne sygnały.
* Spójność środowiska na etapach rozwoju oprogramowania, testowania i działania w trybie produkcyjnym: działa w ten sam sposób na laptopie i w chmurze.
* Możliwość przenoszenia pomiędzy systemami operacyjnymi i platformami chmurowymi: Ubuntu, RHEL, CoreOS, prywatnymi centrami danych, największymi dostawcami usług chmurowych czy gdziekolwiek indziej.
* Zarządzanie, które w centrum uwagi ma aplikacje: Poziom abstrakcji przeniesiony jest z warstwy systemu operacyjnego działającego na maszynie wirtualnej na poziom działania aplikacji, która działa na systemie operacyjnym używając zasobów logicznych.
* Luźno powiązane, rozproszone i elastyczne "swobodne" mikro serwisy: Aplikacje podzielone są na mniejsze, niezależne komponenty, które mogą być dynamicznie uruchamiane i zarządzane - nie jest to monolityczny system działający na jednej, dużej maszynie dedykowanej na wyłączność.
* Izolacja zasobów: wydajność aplikacji możliwa do przewidzenia
* Wykorzystanie zasobów: wysoka wydajność i upakowanie.
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)
---------------------------------------------------------------------
* Poczytaj o [komponentach Kubernetesa](https://kubernetes.io/pl/docs/concepts/overview/components/)
* Poczytaj o [API Kubernetesa](https://kubernetes.io/pl/docs/concepts/overview/kubernetes-api/)
* Poczytaj o [kubectl](https://kubernetes.io/docs/concepts/overview/kubectl/)
- podstawowym narzędziu CLI dla Kubernetesa
* Poczytaj o [architekturze klastra](https://kubernetes.io/pl/docs/concepts/architecture/)
* Jesteś gotowy [zacząć pracę](https://kubernetes.io/pl/docs/setup/)
?
1.1 - Składniki Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#pg-13b0f1dbe89228e3d76d2ac231e245f1)
==================================================================================================================
Omówienie głównych elementów tworzących klaster Kubernetesa.
Ta strona zawiera wysokopoziomy przegląd niezbędnych komponentów, które tworzą klaster Kubernetesa.

Komponenty klastra Kubernetesa
Składniki Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#core-components)
----------------------------------------------------------------------------------------
Klaster Kubernetesa składa się z warstwy sterowania oraz jednego lub więcej węzłów roboczych. Oto krótki przegląd głównych komponentów:
### Części składowe warstwy sterowania[](https://kubernetes.io/pl/docs/concepts/_print/#control-plane-components)
Zarządzanie ogólnym stanem klastra:
[kube-apiserver](https://kubernetes.io/pl/docs/concepts/architecture/#kube-apiserver)
Podstawowy komponent udostępniający interfejs API Kubernetesa przez HTTP.
[etcd](https://kubernetes.io/pl/docs/concepts/architecture/#etcd)
Stabilna i wysoko dostępna baza danych typu klucz-wartość, wykorzystywana do przechowywania stanu całego klastra Kubernetesa.
[kube-scheduler](https://kubernetes.io/pl/docs/concepts/architecture/#kube-scheduler)
Wyszukuje Pody, które nie zostały jeszcze przypisane do węzła, i przydziela każdy Pod do odpowiedniego węzła.
[kube-controller-manager](https://kubernetes.io/pl/docs/concepts/architecture/#kube-controller-manager)
Uruchamia [kontrolery](https://kubernetes.io/pl/docs/concepts/architecture/controller/)
realizujące logikę działania API Kubernetesa.
[cloud-controller-manager](https://kubernetes.io/pl/docs/concepts/architecture/#cloud-controller-manager)
(opcjonalne)
Zapewnia integrację klastra Kubernetesa z infrastrukturą dostarczaną przez zewnętrznych dostawców chmurowych.
### Składniki węzłów[](https://kubernetes.io/pl/docs/concepts/_print/#node-components)
Działa na każdym węźle klastra, odpowiada za utrzymanie aktywnych podów oraz zapewnienie środowiska uruchomieniowego Kubernetesa:
[kubelet](https://kubernetes.io/pl/docs/concepts/architecture/#kubelet)
Odpowiada za nadzorowanie, czy pody oraz ich kontenery są uruchomione i działają zgodnie z oczekiwaniami.
[kube-proxy](https://kubernetes.io/pl/docs/concepts/architecture/#kube-proxy)
(opcjonalne)
Utrzymuje reguły sieciowe na węzłach w celu obsługi komunikacji z [usługami (ang. Service)](https://kubernetes.io/pl/docs/concepts/services-networking/service/)
.
[Środowisko uruchomieniowe kontenerów](https://kubernetes.io/pl/docs/concepts/architecture/#container-runtime)
Oprogramowanie odpowiedzialne za uruchamianie kontenerów. Przeczytaj [Środowiska uruchomieniowe kontenerów](https://kubernetes.io/docs/setup/production-environment/container-runtimes/)
, aby dowiedzieć się więcej.
🛇 Ta pozycja przekierowuje do projektu lub produktu, który nie jest częścią projektu Kubernetes. [Więcej informacji](https://kubernetes.io/pl/docs/concepts/_print/#third-party-content-disclaimer)
Klaster może wymagać dodatkowego oprogramowania na każdym węźle; możesz na przykład uruchomić [systemd](https://systemd.io/)
na węzłach z systemem Linux do monitorowania i zarządzania lokalnymi usługami.
Dodatki (Addons)[](https://kubernetes.io/pl/docs/concepts/_print/#addons)
--------------------------------------------------------------------------
Dodatki rozszerzają funkcjonalność Kubernetesa. Oto kilka ważnych przykładów:
[DNS](https://kubernetes.io/pl/docs/concepts/architecture/#dns)
Umożliwia rozpoznawanie nazw DNS dla usług i komponentów działających w całym klastrze.
[Web UI](https://kubernetes.io/pl/docs/concepts/architecture/#web-ui-dashboard)
(Dashboard)
Umożliwia zarządzanie klastrem Kubernetesa poprzez webowy interfejs.
[Monitorowanie zasobów kontenera](https://kubernetes.io/pl/docs/concepts/architecture/#container-resource-monitoring)
Służy do monitorowania zasobów kontenerów poprzez gromadzenie i zapisywanie danych o ich wydajności.
[Logowanie na poziomie klastra](https://kubernetes.io/pl/docs/concepts/architecture/#cluster-level-logging)
Umożliwia zbieranie i przechowywanie logów z kontenerów w centralnym systemie logowania dostępnym na poziomie całego klastra.
Elastyczność architektury[](https://kubernetes.io/pl/docs/concepts/_print/#flexibility-in-architecture)
--------------------------------------------------------------------------------------------------------
Dzięki elastycznej architekturze Kubernetesa można dostosować sposób wdrażania i zarządzania poszczególnymi komponentami do konkretnych wymagań - od prostych klastrów deweloperskich po złożone systemy produkcyjne na dużą skalę.
Szczegółowe informacje o każdym komponencie oraz różnych sposobach konfiguracji architektury klastra znajdziesz na stronie [Architektura klastra](https://kubernetes.io/pl/docs/concepts/architecture/)
.
1.2 - Objekty w Kubernetesie[](https://kubernetes.io/pl/docs/concepts/_print/#pg-110f33530cf761140cb1dab536baef04)
===================================================================================================================
Obiekty Kubernetesa to trwałe jednostki w systemie Kubernetes. Służą one do odwzorowania stanu klastra. Poznaj, czym jest model obiektów Kubernetesa i jak z nimi pracować.
Ta strona wyjaśnia, jak obiekty Kubernetesa są reprezentowane w API Kubernetesa oraz jak można je wyrazić w formacie `.yaml`.
Czym są obiekty Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#kubernetes-objects)
-------------------------------------------------------------------------------------------------
_Obiekty Kubernetesa_ to trwałe byty w systemie Kubernetes. Kubernetes wykorzystuje te byty do reprezentowania stanu klastra. Konkretne zastosowania to m.in.:
* Jakie aplikacje kontenerowe są uruchomione (i na których węzłach)
* Zasoby dostępne dla tych aplikacji
* Polityki dotyczące zachowania tych aplikacji, takie jak polityki restartu, aktualizacje i tolerancja na błędy
Obiekt Kubernetesa to "zapis zamiaru" - gdy go utworzysz, Kubernetes będzie stale pilnować, aby taki obiekt faktycznie istniał. Tworząc obiekt, efektywnie informujesz Kubernetesa, jak ma wyglądać workload klastra; to jest _pożądany stan_ twojego klastra.
Aby pracować z obiektami Kubernetesa-czy to w celu ich tworzenia, modyfikacji, czy usuwania—musisz użyć [API Kubernetesa](https://kubernetes.io/pl/docs/concepts/overview/kubernetes-api/)
. Na przykład, kiedy używasz interfejsu wiersza poleceń `kubectl`, CLI wykonuje dla ciebie niezbędne wywołania do API Kubernetesa. Możesz także używać API Kubernetesa bezpośrednio w swoich własnych programach, korzystając z jednej z [bibliotek klienckich](https://kubernetes.io/docs/reference/using-api/client-libraries/)
.
### Specyfikacja i status obiektu[](https://kubernetes.io/pl/docs/concepts/_print/#object-spec-and-status)
Prawie każdy obiekt Kubernetesa zawiera dwa zagnieżdżone pola obiektowe, które zarządzają konfiguracją obiektu: obiekt _`spec`_ i obiekt _`status`_. W przypadku obiektów, które mają `spec`, musisz go ustawić podczas tworzenia obiektu, dostarczając opis cech, jakie chcesz, aby zasób posiadał: jego _pożądany stan_.
`Status` opisuje _aktualny stan_ obiektu, dostarczany i aktualizowany przez system Kubernetes i jego komponenty. Kubernetes [warstwa sterowania](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-control-plane)
stale i aktywnie zarządza rzeczywistym stanem każdego obiektu, aby dopasować go do pożądanego stanu, który dostarczyłeś.
Na przykład: w Kubernetesie, Deployment jest obiektem, który może reprezentować aplikację działającą na twoim klastrze. Kiedy tworzysz Deployment, możesz ustawić `spec` Deploymentu, aby określić, że chcesz, aby uruchomione były trzy repliki aplikacji. System Kubernetes odczytuje spec Deploymentu i uruchamia trzy instancje twojej pożądanej aplikacji—aktualizując status, aby dopasować go do twojego spec. Jeśli któraś z instancji ulegnie awarii (czyli zmieni się status), Kubernetes zareaguje na różnicę między spec a status - w tym przypadku, uruchamiając nową instancję.
Aby uzyskać więcej informacji na temat specyfikacji obiektu, statusu i metadanych, zobacz [Kubernetes API Conventions](https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md)
.
### Opis obiektu w Kubernetesie[](https://kubernetes.io/pl/docs/concepts/_print/#describing-a-kubernetes-object)
Kiedy tworzysz obiekt w Kubernetesie, musisz dostarczyć specyfikację obiektu, która opisuje jego pożądany stan, a także podstawowe informacje o obiekcie (takie jak nazwa). Gdy używasz API Kubernetesa do tworzenia obiektu (bezpośrednio lub za pośrednictwem `kubectl`), żądanie API musi zawierać te informacje w formacie JSON w treści żądania. Najczęściej dostarczasz informacje do `kubectl` w pliku znanym jako _manifest_. Zgodnie z konwencją, manifesty są w formacie YAML (możesz również użyć formatu JSON). Narzędzia takie jak `kubectl` konwertują informacje z manifestu na JSON lub inny obsługiwany format serializacji podczas wysyłania żądania API przez HTTP.
Oto przykład manifestu pokazujący wymagane pola oraz specyfikację obiektu dla Deployment w Kubernetesie:
[`application/deployment.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/pl/examples/application/deployment.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
spec:
selector:
matchLabels:
app: nginx
replicas: 2 # tells deployment to run 2 pods matching the template
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
Jednym ze sposobów utworzenia Deploymentu przy użyciu pliku manifestu, takiego jak powyżej, jest użycie polecenia [`kubectl apply`](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply)
w interfejsie wiersza poleceń `kubectl`, przekazując plik `.yaml` jako argument. Oto przykład:
kubectl apply -f https://k8s.io/examples/application/deployment.yaml
Wynik jest podobny do tego:
deployment.apps/nginx-deployment created
### Wymagane pola[](https://kubernetes.io/pl/docs/concepts/_print/#required-fields)
W manifeście (pliku YAML lub JSON) dla obiektu Kubernetesa, który chcesz utworzyć, musisz ustawić wartości dla następujących pól:
* `apiVersion` - Której wersji API Kubernetesa używasz do utworzenia tego obiektu
* `kind` - Jakiego rodzaju obiekt chcesz utworzyć
* `metadata` - Dane pomagające jednoznacznie zidentyfikować obiekt, w tym łańcuch znaków `name`, `UID` oraz opcjonalnie `namespace`.
* `spec` - Jaki stan jest pożądany dla obiektu
Dokładny format obiektu `spec` jest inny dla każdego obiektu Kubernetesa i zawiera zagnieżdżone pola specyficzne dla tego obiektu. [Kubernetes API Reference](https://kubernetes.io/docs/reference/kubernetes-api/)
może pomóc ci znaleźć format spec dla wszystkich obiektów, które możesz utworzyć przy użyciu Kubernetesa.
Na przykład, zobacz [pole `spec`](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#PodSpec)
w odniesieniu do API Poda. Dla każdego Poda, pole `.spec` określa pod i jego pożądany stan (taki jak nazwa obrazu kontenera dla każdego kontenera w ramach tego poda). Innym przykładem specyfikacji obiektu jest [pole `spec`](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/stateful-set-v1/#StatefulSetSpec)
dla API StatefulSet. Dla StatefulSet, pole `.spec` określa StatefulSet i jego pożądany stan. W ramach `.spec` dla StatefulSet znajduje się [szablon](https://kubernetes.io/pl/docs/concepts/workloads/pods/#pod-templates)
dla obiektów Pod. Ten szablon opisuje Pody, które kontroler StatefulSet utworzy w celu spełnienia specyfikacji StatefulSet. Różne rodzaje obiektów mogą również mieć różne `.status`; ponownie, strony referencyjne API szczegółowo opisują strukturę tego pola `.status` i jego zawartość dla każdego rodzaju obiektu.
Zobacz [Najlepsze Praktyki Konfiguracji](https://kubernetes.io/blog/2025/11/25/configuration-good-practices/)
aby uzyskać dodatkowe informacje na temat pisania plików konfiguracyjnych YAML.
Walidacja pól po stronie serwera[](https://kubernetes.io/pl/docs/concepts/_print/#server-side-field-validation)
----------------------------------------------------------------------------------------------------------------
Począwszy od wersji Kubernetesa v1.25, serwer API oferuje [walidację pól](https://kubernetes.io/docs/reference/using-api/api-concepts/#field-validation)
po stronie serwera, która wykrywa nierozpoznane lub zduplikowane pola w obiekcie. Zapewnia ona całą funkcjonalność `kubectl --validate` po stronie serwera.
Narzędzie `kubectl` używa flagi `--validate` do ustawiania poziomu walidacji pól. Akceptuje wartości `ignore`, `warn` oraz `strict`, a także akceptuje wartości `true` (równoważne `strict`) i `false` (równoważne `ignore`). Domyślne ustawienie walidacji dla `kubectl` to `--validate=true`.
`Strict` : Ścisła walidacja pól, błędy w przypadku niepowodzenia walidacji
`Warn` : Walidacja pola jest przeprowadzana, ale błędy są zgłaszane jako ostrzeżenia zamiast powodować niepowodzenie żądania.
`Ignore` : Nie jest wykonywana żadna walidacja pola po stronie serwera
Kiedy `kubectl` nie może połączyć się z serwerem API, który obsługuje walidację pól, przełączy się na użycie walidacji po stronie klienta. Kubernetes 1.27 i nowsze wersje zawsze oferują walidację pól; starsze wydania Kubernetesa mogą tego nie robić. Jeśli twój klaster jest starszy niż v1.27, sprawdź dokumentację dla swojej wersji Kubernetesa.
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)
---------------------------------------------------------------------
Jeśli dopiero zaczynasz swoją przygodę z Kubernetesem, przeczytaj więcej na temat:
* [Pody](https://kubernetes.io/pl/docs/concepts/workloads/pods/)
, które są najważniejszymi podstawowymi obiektami Kubernetesa.
* Obiekty [Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
.
* [Kontrolery](https://kubernetes.io/docs/concepts/architecture/controller/)
w Kubernetesie.
* [kubectl](https://kubernetes.io/docs/reference/kubectl/)
i [kubectl commands](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands)
.
[Zarządzanie obiektami Kubernetesa](https://kubernetes.io/docs/concepts/overview/working-with-objects/object-management/)
wyjaśnia, jak używać `kubectl` do zarządzania obiektami. Możesz potrzebować [zainstalować kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl)
, jeśli jeszcze go nie masz.
Aby dowiedzieć się więcej ogólnie o API Kubernetesa, odwiedź:
* [Kubernetes API overview](https://kubernetes.io/docs/reference/using-api/)
Aby dowiedzieć się więcej o obiektach w Kubernetesie, przeczytaj inne strony w tej sekcji:
1.2.1 - Nazwy i identyfikatory objektów[](https://kubernetes.io/pl/docs/concepts/_print/#pg-f37749a83c2916b63279ea60f3cfe53e)
==============================================================================================================================
Każdy [obiekt](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/#kubernetes-objects)
w Twoim klastrze ma [_Nazwę_](https://kubernetes.io/pl/docs/concepts/_print/#names)
, która jest unikalna dla tego typu zasobu. Każdy obiekt Kubernetesa posiada również [_UID_](https://kubernetes.io/pl/docs/concepts/_print/#uids)
, który jest unikalny w całym Twoim klastrze.
Na przykład, w jednym [namespace](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/namespaces/)
można mieć tylko jeden Pod o nazwie `myapp-1234`, ale można mieć jeden Pod i jeden Deployment, które są nazwane `myapp-1234`.
Dla nieunikalnych atrybutów dostarczonych przez użytkownika, Kubernetes udostępnia [etykiety](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels/)
oraz [adnotacje](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/annotations/)
.
Nazwy[](https://kubernetes.io/pl/docs/concepts/_print/#names)
--------------------------------------------------------------
Ciąg znaków dostarczony przez klienta, który odnosi się do obiektu w adresie URL [zasobu](https://kubernetes.io/pl/docs/reference/using-api/api-concepts/#standard-api-terminology)
, na przykład `/api/v1/pods/some-name`.
W danym momencie tylko jeden obiekt danego typu może mieć określoną nazwę. Jednak po usunięciu tego obiektu można utworzyć nowy o tej samej nazwie.
**Nazwy muszą być unikalne we wszystkich [wersjach API](https://kubernetes.io/pl/docs/concepts/overview/kubernetes-api/#api-groups-and-versioning)
dla tego samego zasobu. Zasoby API są rozróżniane na podstawie grupy API, typu zasobu, przestrzeni nazw (dla zasobów przestrzeniozależnych) oraz nazwy. Innymi słowy, wersja API jest nieistotna w tym kontekście.**
#### Informacja:
W przypadkach, gdy obiekty reprezentują fizyczną jednostkę, jak Node reprezentujący fizycznego hosta, jeśli host jest odtworzony pod tą samą nazwą bez usuwania i ponownego tworzenia Node, Kubernetes traktuje nowy host jako stary, co może prowadzić do niespójności.
Serwer może wygenerować nazwę, gdy zamiast `name` w żądaniu utworzenia zasobu podano `generateName`. Gdy używane jest `generateName`, podana wartość służy jako prefiks nazwy, do którego serwer dodaje wygenerowany sufiks. Nawet jeśli nazwa jest generowana, może wystąpić konflikt z istniejącymi nazwami, co skutkuje odpowiedzią HTTP 409. W Kubernetes v1.31 i nowszych wersjach jest to znacznie mniej prawdopodobne, ponieważ serwer podejmuje do 8 prób wygenerowania unikalnej nazwy przed zwróceniem odpowiedzi HTTP 409.
Poniżej znajdują się cztery typy często używanych ograniczeń nazw dla zasobów.
### Nazwy subdomen DNS[](https://kubernetes.io/pl/docs/concepts/_print/#dns-subdomain-names)
Większość typów zasobów wymaga nazwy, która może być używana jako nazwa poddomeny DNS, zgodnie z definicją w [RFC 1123](https://tools.ietf.org/html/rfc1123)
. Oznacza to, że nazwa musi:
* zawierać nie więcej niż 253 znaki
* zawierać tylko małe litery alfanumeryczne, '-' lub '.'
* zaczynać się od znaku alfanumerycznego
* kończyć się znakiem alfanumerycznym
### Nazwy etykiet zgodnie z RFC 1123[](https://kubernetes.io/pl/docs/concepts/_print/#dns-label-names)
Niektóre typy zasobów wymagają, aby ich nazwy były zgodne ze standardem etykiet DNS, jak zdefiniowano w [RFC 1123](https://tools.ietf.org/html/rfc1123)
. Oznacza to, że nazwa musi:
* zawierać maksymalnie 63 znaków
* zawierać tylko małe litery alfanumeryczne lub '-'
* zaczynać się od litery alfabetu
* kończyć się znakiem alfanumerycznym
#### Informacja:
Gdy bramka funkcji `RelaxedServiceNameValidation` jest włączona, nazwy obiektów usługi (ang. Service) mogą rozpoczynać się od cyfry.
### Nazwy etykiet zgodne z RFC 1035[](https://kubernetes.io/pl/docs/concepts/_print/#rfc-1035-label-names)
Niektóre typy zasobów wymagają, aby ich nazwy spełniały standardy etykiet DNS zgodnie z definicją w [RFC 1035](https://tools.ietf.org/html/rfc1035)
. Oznacza to, że nazwa musi:
* zawierać maksymalnie 63 znaków
* zawierać tylko małe litery alfanumeryczne lub '-'
* zaczynać się od litery alfabetu
* kończyć się znakiem alfanumerycznym
#### Informacja:
Chociaż RFC 1123 technicznie pozwala, aby etykiety zaczynały się od cyfr, obecna implementacja Kubernetesa wymaga, aby zarówno etykiety (ang. label) zgodne z RFC 1035, jak i RFC 1123 zaczynały się od znaku alfabetycznego. Wyjątkiem jest sytuacja, gdy dla obiektów typu Service jest włączona brama funkcji `RelaxedServiceNameValidation`, co pozwala na to, aby nazwy usług zaczynały się od cyfr.
### Nazwy segmentów ścieżki[](https://kubernetes.io/pl/docs/concepts/_print/#path-segment-names)
Niektóre typy zasobów wymagają, aby ich nazwy mogły być bezpiecznie kodowane jako segment ścieżki. Innymi słowy, nazwa nie może być "." ani ".." oraz nie może zawierać "/" ani "%".
Oto przykładowy manifest dla Poda o nazwie `nginx-demo`.
apiVersion: v1
kind: Pod
metadata:
name: nginx-demo
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
#### Informacja:
Niektóre typy zasobów mają dodatkowe ograniczenia dotyczące ich nazw.
UIDy[](https://kubernetes.io/pl/docs/concepts/_print/#uids)
------------------------------------------------------------
Unikalny identyfikator obiektu generowany automatycznie przez system Kubernetes.
Każdy obiekt utworzony w trakcie całego cyklu życia klastra Kubernetesa posiada unikalny UID. Jego celem jest rozróżnianie historycznych wystąpień podobnych jednostek.
UID-y Kubernetesa to uniwersalne unikalne identyfikatory (znane również jako UUID). UUID są ustandaryzowane jako ISO/IEC 9834-8 oraz jako ITU-T X.667.
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)
---------------------------------------------------------------------
* Przeczytaj o [etykietach](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels/)
i [adnotacjach](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/annotations/)
w Kubernetesie.
* Zobacz [Identyfikatory i nazwy w Kubernetesie](https://git.k8s.io/design-proposals-archive/architecture/identifiers.md)
.
1.2.2 - Etykiety i selektory[](https://kubernetes.io/pl/docs/concepts/_print/#pg-f1dec4557fb8ffbac9f11390aaaf9fa4)
===================================================================================================================
_Etykiety_ to pary klucz/wartość, które są dołączane do [obiektów](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/#kubernetes-objects)
takich jak Pody. Etykiety służą do określania identyfikacyjnych atrybutów obiektów, które są istotne i ważne dla użytkowników, ale bezpośrednio nie wpływają na semantykę głównego systemu. Etykiety mogą być używane do organizowania i wybierania podzbiorów obiektów. Etykiety mogą być dołączane do obiektów w momencie ich tworzenia, a następnie mogą być dodawane i modyfikowane w dowolnym momencie. Każdy obiekt może mieć zdefiniowany zestaw etykiet w postaci par klucz/wartość. Każdy klucz musi być unikalny dla konkretnego obiektu.
"metadata": {
"labels": {
"key1" : "value1",
"key2" : "value2"
}
}
Etykiety umożliwiają wydajne zapytania i obserwacje, co czyni je idealnym rozwiązaniem do użycia w interfejsach użytkownika (UI) i interfejsach wiersza poleceń (CLI). Informacje nieidentyfikujące powinny być rejestrowane przy użyciu [adnotacji](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/annotations/)
.
Motywacja[](https://kubernetes.io/pl/docs/concepts/_print/#motivation)
-----------------------------------------------------------------------
Etykiety umożliwiają użytkownikom odwzorowanie własnych struktur organizacyjnych na obiekty systemowe w sposób luźno powiązany, bez konieczności przechowywania tych odwzorowań przez klientów.
Rozmieszczanie usług i przetwarzanie wsadowe to często byty wielowymiarowe (np. wiele partycji lub wdrożeń, wiele ścieżek wydania, wiele poziomów, wiele mikrousług na poziom). Zarządzanie często wymaga operacji przekrojowych, co łamie enkapsulację ściśle hierarchicznych reprezentacji, zwłaszcza sztywnych hierarchii określanych przez infrastrukturę, a nie przez użytkowników.
Przykłady etykiet:
* `"release" : "stable"`, `"release" : "canary"`
* `"environment" : "dev"`, `"environment" : "qa"`, `"environment" : "production"`
* `"tier" : "frontend"`, `"tier" : "backend"`, `"tier" : "cache"`
* `"partition" : "customerA"`, `"partition" : "customerB"`
* `"track" : "daily"`, `"track" : "weekly"`
Oto przykłady [zalecanych etykiet](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/common-labels/)
; możesz swobodnie opracowywać własne konwencje. Pamiętaj, że klucz etykiety musi być unikalny dla danego obiektu.
Składnia i zestaw znaków[](https://kubernetes.io/pl/docs/concepts/_print/#syntax-and-character-set)
----------------------------------------------------------------------------------------------------
_Etykiety_ to pary klucz/wartość. Prawidłowe klucze etykiet mają dwa segmenty: opcjonalny prefiks i nazwę, oddzielone ukośnikiem (`/`). Segment nazwy jest wymagany i musi mieć maksymalnie 63 znaki, zaczynając i kończąc się znakiem alfanumerycznym (`[a-z0-9A-Z]`), z myślnikami (`-`), podkreśleniami (`_`), kropkami (`.`) i znakami alfanumerycznymi pomiędzy. Prefiks jest opcjonalny. Jeśli jest podany, prefiks musi być subdomeną DNS: serią etykiet DNS oddzielonych kropkami (`.`), o długości nieprzekraczającej łącznie 253 znaków, zakończoną ukośnikiem (`/`).
Jeśli prefiks zostanie pominięty, uważa się, że klucz etykiety jest prywatny dla użytkownika. Zautomatyzowane komponenty systemowe (np. `kube-scheduler`, `kube-controller-manager`, `kube-apiserver`, `kubectl` lub inne zewnętrzne automatyzacje), które dodają etykiety do obiektów końcowego użytkownika, muszą określać prefiks.
Prefiksy `kubernetes.io/` i `k8s.io/` są [zarezerwowane](https://kubernetes.io/docs/reference/labels-annotations-taints/)
dla podstawowych komponentów Kubernetesa.
Prawidłowa wartość etykiety:
* musi mieć 63 znaki lub mniej (może być puste),
* o ile ciąg nie jest pusty, musi zaczynać się i kończyć znakiem alfanumerycznym (`[a-z0-9A-Z]`),
* może zawierać myślniki (`-`), podkreślenia (`_`), kropki (`.`) oraz znaki alfanumeryczne pomiędzy.
Na przykład, oto manifest dla Poda, który ma dwie etykiety `environment: production` oraz `app: nginx`:
apiVersion: v1
kind: Pod
metadata:
name: label-demo
labels:
environment: production
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
Selektory etykiet[](https://kubernetes.io/pl/docs/concepts/_print/#label-selectors)
------------------------------------------------------------------------------------
W przeciwieństwie do [nazw i identyfikatorów UID](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/names/)
, etykiety nie zapewniają unikalności. To oznacza, że wiele obiektów może mieć te same etykiety.
Za pomocą _selektora etykiet_ klient/użytkownik może zidentyfikować zestaw obiektów. Selektor etykiet jest podstawowym mechanizmem grupującym w Kubernetesie.
API obecnie obsługuje dwa typy selektorów: _oparte na równości_ i _oparte na zbiorach_. Selektor etykiet może składać się z wielu _wymagań_, które są oddzielone przecinkami. W przypadku wielu wymagań, wszystkie muszą być spełnione, więc separator przecinka działa jako logiczny operator _AND_ (`&&`).
Interpretacja pustych lub niepodanych selektorów zależy od kontekstu. Każdy typ API, który je wykorzystuje, powinien jasno udokumentować ich dopuszczalność i sposób działania.
#### Informacja:
Dla niektórych typów API, takich jak ReplicaSets, selektory etykiet dwóch instancji nie mogą się nakładać w obrębie jednej przestrzeni nazw, ponieważ kontroler może to uznać za sprzeczne polecenia i nie będzie w stanie określić, ile replik powinno być obecnych.
#### Uwaga:
Zarówno dla warunków opartych na równości, jak i warunków opartych na zbiorach nie istnieje operator logiczny _OR_ (`||`). Upewnij się, że twoje instrukcje filtrujące są odpowiednio skonstruowane.
### _Wymóg oparty na równości_[](https://kubernetes.io/pl/docs/concepts/_print/#equality-based-requirement)
_Wymagania_ oparte na _równości_ lub _nierówności_ umożliwiają filtrowanie według kluczy i wartości etykiet. Pasujące obiekty muszą spełniać wszystkie określone ograniczenia etykiet, chociaż mogą mieć również dodatkowe etykiety. Dopuszczalne są trzy rodzaje operatorów: `=`,`==`,`!=`. Pierwsze dwa reprezentują _równość_ (i są synonimami), podczas gdy ostatni reprezentuje _nierówność_. Na przykład:
environment = production
tier != frontend
Poprzedni wybiera wszystkie zasoby, których klucz jest równy `environment`, a wartość równa się `production`. Drugi wybiera wszystkie zasoby, których klucz jest równy `tier`, a wartość różni się od `frontend`, oraz wszystkie zasoby bez etykiet z kluczem `tier`. Można filtrować zasoby w `production` wyłączając `frontend` przy użyciu operatora przecinka: `environment=production,tier!=frontend`
Jednym ze scenariuszy użycia dla wymagań etykiet opartych na równości jest specyfikacja kryteriów wyboru węzła przez Pody. Na przykład, poniższy przykładowy Pod wybiera węzły, na których etykieta `accelerator` istnieje i jest ustawiona na `nvidia-tesla-p100`.
apiVersion: v1
kind: Pod
metadata:
name: cuda-test
spec:
containers:
- name: cuda-test
image: "registry.k8s.io/cuda-vector-add:v0.1"
resources:
limits:
nvidia.com/gpu: 1
nodeSelector:
accelerator: nvidia-tesla-p100
### _Wymagania oparte na zbiorach_[](https://kubernetes.io/pl/docs/concepts/_print/#set-based-requirement)
Wymagania dotyczące etykiet bazujących na zbiorach (_Set-based_) umożliwiają filtrowanie kluczy według zbioru wartości. Obsługiwane są trzy rodzaje operatorów: `in`, `notin` oraz `exists` (tylko identyfikator klucza). Na przykład:
environment in (production, qa)
tier notin (frontend, backend)
partition
!partition
* Pierwszy przykład wybiera wszystkie zasoby z kluczem równym `environment` i wartością równą `production` lub `qa`.
* Drugi przykład wybiera wszystkie zasoby z kluczem równym `tier` i wartościami innymi niż `frontend` i `backend`, oraz wszystkie zasoby bez etykiet z kluczem `tier`.
* Trzeci przykład wybiera wszystkie zasoby zawierające etykietę z kluczem `partition`; wartości nie są sprawdzane.
* Czwarty przykład wybiera wszystkie zasoby bez etykiety z kluczem `partition`; wartości nie są sprawdzane.
Podobnie separator przecinka działa jako operator _AND_. Filtrowanie zasobów z kluczem `partition` (bez względu na wartość) i z `environment` innym niż `qa` można osiągnąć używając `partition,environment notin (qa)`. _Selekcja etykiet oparta na zbiorach_ jest ogólną formą równości, ponieważ `environment=production` jest równoważne `environment in (production)`; podobnie dla `!=` i `notin`.
Wymagania oparte na _zbiorach_ mogą być mieszane z wymaganiami opartymi na _równości_. Na przykład: `partition in (customerA, customerB),environment!=qa`.
API[](https://kubernetes.io/pl/docs/concepts/_print/#api)
----------------------------------------------------------
### Filtrowanie LIST i WATCH[](https://kubernetes.io/pl/docs/concepts/_print/#list-and-watch-filtering)
Dla operacji **list** i **watch** można określić selektory etykiet, aby filtrować zestawy zwracanych obiektów; filtr określasz za pomocą parametru zapytania. (Aby dowiedzieć się więcej o mechanizmie watch w Kubernetesie, przeczytaj o [wydajnym wykrywaniu zmian](https://kubernetes.io/docs/reference/using-api/api-concepts/#efficient-detection-of-changes)
). Oba wymagania są dozwolone (przedstawione tutaj tak, jak mogą się pojawić w ciągu zapytania URL):
* _wymagania oparte na równości_: `?labelSelector=environment%3Dproduction,tier%3Dfrontend`
* \_wymagania oparte na zbiorach: `?labelSelector=environment+in+%28production%2Cqa%29%2Ctier+in+%28frontend%29`
Oba style selektorów etykiet mogą być używane do wylistowania lub obserwacji zasobów za pomocą klienta REST. Na przykład, kierując się na `apiserver` z `kubectl` i używając selekcji opartej na równości, można napisać:
kubectl get pods -l environment=production,tier=frontend
lub używając wymagań opartych na _zbiorach_:
kubectl get pods -l 'environment in (production),tier in (frontend)'
Jak już wspomniano, wymagania oparte na _zbiorach_ są bardziej wyraziste. Na przykład mogą implementować operator _LUB_ na wartościach:
kubectl get pods -l 'environment in (production, qa)'
lub ograniczenie dopasowywania negatywnego za pomocą operatora _notin_:
kubectl get pods -l 'environment,environment notin (frontend)'
### Ustaw referencje w obiektach API[](https://kubernetes.io/pl/docs/concepts/_print/#set-references-in-api-objects)
Niektóre obiekty Kubernetesa, takie jak [`services`](https://kubernetes.io/docs/concepts/services-networking/service/)
i [`replicationcontrollers`](https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/)
, również używają selektorów etykiet do określania zbiorów innych zasobów, takich jak [pods](https://kubernetes.io/pl/docs/concepts/workloads/pods/)
.
#### Usługa i Kontroler Replikacji[](https://kubernetes.io/pl/docs/concepts/_print/#service-and-replicationcontroller)
Zestaw podów, na które skierowana jest usługa (`service`), jest określany za pomocą selektora etykiet. Podobnie, populacja podów, którą powinien zarządzać kontroler replikacji (`replicationcontroller`), jest również określana za pomocą selektora etykiet.
Selektory etykiet dla obu obiektów są definiowane w plikach `json` lub `yaml` za pomocą map, i obsługiwane są tylko selektory wymagań oparte na _równości_:
"selector": {
"component" : "redis",
}
lub
selector:
component: redis
Ten selektor (odpowiednio w formacie `json` lub `yaml`) jest równoważny z `component=redis` lub `component in (redis)`.
#### Zasoby, które obsługują wymagania oparte na zbiorach[](https://kubernetes.io/pl/docs/concepts/_print/#resources-that-support-set-based-requirements)
Nowsze zasoby, takie jak [`Job`](https://kubernetes.io/docs/concepts/workloads/controllers/job/)
, [`Deployment`](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
, [`ReplicaSet`](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)
oraz [`DaemonSet`](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)
, obsługują również wymagania _oparte na zbiorach_.
selector:
matchLabels:
component: redis
matchExpressions:
- { key: tier, operator: In, values: [cache] }
- { key: environment, operator: NotIn, values: [dev] }
`matchLabels` to mapa par `{klucz,wartość}`. Pojedyncza para `{klucz,wartość}` w mapie `matchLabels` jest równoważna elementowi `matchExpressions`, którego pole `key` to "klucz", `operator` to "In", a tablica `values` zawiera wyłącznie "wartość". `matchExpressions` to lista wymagań selektora podów. Prawidłowe operatory to In, NotIn, Exists i DoesNotExist. Zbiór wartości musi być niepusty w przypadku In i NotIn. Wszystkie wymagania zarówno z `matchLabels`, jak i `matchExpressions` są łączone za pomocą operatora AND - muszą być wszystkie spełnione, aby dopasowanie było możliwe.
#### Wybieranie zestawów węzłów[](https://kubernetes.io/pl/docs/concepts/_print/#selecting-sets-of-nodes)
Jednym z przypadków użycia wybierania w oparciu o etykiety jest ograniczenie zestawu węzłów, na które można umieścić pod. Więcej informacji można znaleźć w dokumentacji na temat [wyboru węzła](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/)
.
Skuteczne wykorzystywanie etykiet[](https://kubernetes.io/pl/docs/concepts/_print/#using-labels-effectively)
-------------------------------------------------------------------------------------------------------------
Możesz zastosować pojedynczą etykietę do dowolnych zasobów, ale nie zawsze jest to najlepsza praktyka. Istnieje wiele scenariuszy, w których należy użyć wielu etykiet, aby odróżnić zestawy zasobów od siebie nawzajem.
Na przykład różne aplikacje mogą używać różnych wartości dla etykiety `app`, ale aplikacja wielowarstwowa, taka jak [przykład książki gości](https://github.com/kubernetes/examples/tree/master/web/guestbook/)
, będzie dodatkowo musiała rozróżniać każdą warstwę. Frontend mógłby nosić następujące etykiety:
labels:
app: guestbook
tier: frontend
podczas gdy instancje master i replica Redis miałyby różne etykiety `tier`, a być może nawet dodatkową etykietę `role`:
labels:
app: guestbook
tier: backend
role: master
i
labels:
app: guestbook
tier: backend
role: replica
Etykiety umożliwiają sortowanie i filtrowanie zasobów według dowolnego wymiaru określonego przez etykietę:
kubectl apply -f examples/guestbook/all-in-one/guestbook-all-in-one.yaml
kubectl get pods -Lapp -Ltier -Lrole
NAME READY STATUS RESTARTS AGE APP TIER ROLE
guestbook-fe-4nlpb 1/1 Running 0 1m guestbook frontend
guestbook-fe-ght6d 1/1 Running 0 1m guestbook frontend
guestbook-fe-jpy62 1/1 Running 0 1m guestbook frontend
guestbook-redis-master-5pg3b 1/1 Running 0 1m guestbook backend master
guestbook-redis-replica-2q2yf 1/1 Running 0 1m guestbook backend replica
guestbook-redis-replica-qgazl 1/1 Running 0 1m guestbook backend replica
my-nginx-divi2 1/1 Running 0 29m nginx
my-nginx-o0ef1 1/1 Running 0 29m nginx
kubectl get pods -lapp=guestbook,role=replica
NAME READY STATUS RESTARTS AGE
guestbook-redis-replica-2q2yf 1/1 Running 0 3m
guestbook-redis-replica-qgazl 1/1 Running 0 3m
Aktualizacja etykiet[](https://kubernetes.io/pl/docs/concepts/_print/#updating-labels)
---------------------------------------------------------------------------------------
Czasami możesz chcieć zmienić etykiety istniejących podów i innych zasobów przed utworzeniem nowych zasobów. Można to zrobić za pomocą `kubectl label`. Na przykład, jeśli chcesz oznaczyć wszystkie swoje pody NGINX jako warstwę frontendową, wykonaj:
kubectl label pods -l app=nginx tier=fe
pod/my-nginx-2035384211-j5fhi labeled
pod/my-nginx-2035384211-u2c7e labeled
pod/my-nginx-2035384211-u3t6x labeled
Najpierw filtruje wszystkie pody z etykietą "app=nginx", a następnie nadaje im etykietę "tier=fe". Aby zobaczyć pody, które zostały oznaczone etykietą, uruchom:
kubectl get pods -l app=nginx -L tier
NAME READY STATUS RESTARTS AGE TIER
my-nginx-2035384211-j5fhi 1/1 Running 0 23m fe
my-nginx-2035384211-u2c7e 1/1 Running 0 23m fe
my-nginx-2035384211-u3t6x 1/1 Running 0 23m fe
To wyświetla wszystkie pody z etykietą "app=nginx", z dodatkową kolumną etykiet reprezentującą warstwę podów (określoną za pomocą `-L` lub `--label-columns`).
Aby uzyskać więcej informacji, zobacz [kubectl label](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands/#label)
.
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)
---------------------------------------------------------------------
* Dowiedz się, jak [dodać etykietę do węzła](https://kubernetes.io/docs/tasks/configure-pod-container/assign-pods-nodes/#add-a-label-to-a-node)
* Zobacz [Well-known labels, Annotations and Taints](https://kubernetes.io/docs/reference/labels-annotations-taints/)
* Zobacz [Zalecane etykiety](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/common-labels/)
* [Enforce Pod Security Standards with Namespace Labels](https://kubernetes.io/docs/tasks/configure-pod-container/enforce-standards-namespace-labels/)
* Przeczytaj blog [Writing a Controller for Pod Labels](https://kubernetes.io/blog/2021/06/21/writing-a-controller-for-pod-labels/)
1.2.3 - Przestrzenie nazw (ang. Namespaces)[](https://kubernetes.io/pl/docs/concepts/_print/#pg-1127165f472b7181b9c1d5a0b187d620)
==================================================================================================================================
W Kubernetesie _przestrzenie nazw_ zapewniają mechanizm izolowania grup zasobów w ramach jednego klastra. Nazwy zasobów muszą być unikalne w obrębie danej przestrzeni nazw, ale nie muszą być unikalne w całym klastrze. Zakres oparty na przestrzeniach nazw dotyczy tylko [obiektów](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/#kubernetes-objects)
_(np. Deploymentów, Service'ów, itp.)_, a nie dla obiektów dotyczących całego klastra _(np. StorageClass, Nodes, PersistentVolumes, itp.)_.
Kiedy używać wielu przestrzeni nazw[](https://kubernetes.io/pl/docs/concepts/_print/#when-to-use-multiple-namespaces)
----------------------------------------------------------------------------------------------------------------------
Przestrzenie nazw są przeznaczone do użycia w środowiskach z wieloma użytkownikami rozproszonymi w różnych zespołach lub projektach. Dla klastrów z użytkownikami w ilości od kilku do kilkunastu nie powinieneś potrzebować tworzyć ani myśleć o przestrzeniach nazw. Zacznij używać przestrzeni nazw, gdy potrzebujesz funkcji, które one oferują.
Namespace'y zapewniają zakres dla nazw. Nazwy zasobów muszą być unikalne w obrębie jednego namespace'u, ale nie muszą być unikalne w różnych namespace'ach. Namespace'y nie mogą być zagnieżdżane w sobie wzajemnie, a każdy zasób Kubernetesa może znajdować się tylko w jednym namespace'ie.
Namespacey są sposobem na podział zasobów klastra pomiędzy wielu użytkowników (przez [resource quotas](https://kubernetes.io/docs/concepts/policy/resource-quotas/)
).
Nie ma potrzeby używania wielu przestrzeni nazw do oddzielania nieznacznie różniących się zasobów, takich jak różne wersje tego samego oprogramowania: zamiast tego wykorzystaj [etykiety](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels)
, aby rozróżnić zasoby w obrębie jednej przestrzeni nazw.
#### Informacja:
Dla klastra produkcyjnego, rozważ _nie_ używanie przestrzeni nazw `default`. Zamiast tego stwórz inne przestrzenie nazw i używaj ich.
Początkowe przestrzenie nazw[](https://kubernetes.io/pl/docs/concepts/_print/#initial-namespaces)
--------------------------------------------------------------------------------------------------
Kubernetes rozpoczyna z czterema początkowymi przestrzeniami nazw:
`default` : Kubernetes zawiera tę przestrzeń nazw, aby umożliwić rozpoczęcie korzystania z nowego klastra bez konieczności wcześniejszego tworzenia przestrzeni nazw.
`kube-node-lease` : Ta przestrzeń nazw przechowuje obiekty [Lease](https://kubernetes.io/docs/concepts/architecture/leases/)
powiązane z każdym węzłem. Pozwalają one kubeletowi na wysyłanie [sygnałów życia (ang. heartbeats)](https://kubernetes.io/docs/concepts/architecture/nodes/#node-heartbeats)
, dzięki czemu warstwa sterowania może wykryć awarię węzła.
`kube-public` : Ta przestrzeń nazw jest możliwa do odczytu przez _wszystkich_ klientów (w tym tych, którzy nie są uwierzytelnieni). Ta przestrzeń nazw jest głównie zarezerwowana do użytku klastra, na wypadek gdyby niektóre zasoby miały być widoczne i czytelne publicznie w całym klastrze. Publiczny aspekt tej przestrzeni nazw jest jedynie konwencją, a nie wymogiem.
`kube-system` : Przestrzeń nazw dla obiektów tworzonych przez system Kubernetesa.
Praca z przestrzeniami nazw[](https://kubernetes.io/pl/docs/concepts/_print/#working-with-namespaces)
------------------------------------------------------------------------------------------------------
Tworzenie i usuwanie przestrzeni nazw zostało opisane w [dokumentacji Przewodnika Administratora dotyczącej przestrzeni nazw](https://kubernetes.io/docs/tasks/administer-cluster/namespaces)
.
#### Informacja:
Unikaj tworzenia przestrzeni nazw z prefiksem `kube-`, ponieważ jest on zarezerwowany dla przestrzeni nazw systemu Kubernetes.
### Przeglądanie przestrzeni nazw[](https://kubernetes.io/pl/docs/concepts/_print/#viewing-namespaces)
Możesz wyświetlić listę bieżących przestrzeni nazw w klastrze za pomocą:
kubectl get namespace
NAME STATUS AGE
default Active 1d
kube-node-lease Active 1d
kube-public Active 1d
kube-system Active 1d
### Ustawianie przestrzeni nazw dla żądania[](https://kubernetes.io/pl/docs/concepts/_print/#setting-the-namespace-for-a-request)
Aby ustawić przestrzeń nazw dla bieżącego żądania, użyj flagi `--namespace`.
Na przykład:
kubectl run nginx --image=nginx --namespace=
kubectl get pods --namespace=
### Ustawianie preferencji przestrzeni nazw[](https://kubernetes.io/pl/docs/concepts/_print/#setting-the-namespace-preference)
Możesz na stałe zapisać przestrzeń nazw dla wszystkich kolejnych poleceń kubectl w tym kontekście.
kubectl config set-context --current --namespace=
# Validate it
kubectl config view --minify | grep namespace:
Przestrzenie nazw i DNS[](https://kubernetes.io/pl/docs/concepts/_print/#namespaces-and-dns)
---------------------------------------------------------------------------------------------
Kiedy tworzysz [Service](https://kubernetes.io/docs/concepts/services-networking/service/)
, tworzy on odpowiadający mu [rekord DNS](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)
. Ten wpis ma postać `..svc.cluster.local`, co oznacza, że jeśli kontener używa tylko ``, odwołuje się on do usługi lokalnej dla danego namespace'a. Jest to przydatne do używania tej samej konfiguracji w wielu namespace'ach, takich jak Development, Staging i Production. Jeśli chcesz uzyskać dostęp do zasobów między namespace'ami, musisz użyć w pełni kwalifikowanej nazwy domeny (FQDN).
W związku z tym, wszystkie nazwy przestrzeni nazw muszą być zgodne z [etykietami DNS RFC 1123](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/names/#dns-label-names)
.
#### Ostrzeżenie:
Poprzez tworzenie przestrzeni nazw o takiej samej nazwie jak [publiczne domeny najwyższego poziomu](https://data.iana.org/TLD/tlds-alpha-by-domain.txt)
, usługi w tych przestrzeniach nazw mogą mieć krótkie nazwy DNS, które pokrywają się z publicznymi rekordami DNS. Zapytania DNS wykonywane przez workloady z dowolnej przestrzeni nazw, bez [kończącej kropki](https://datatracker.ietf.org/doc/html/rfc1034#page-8)
, będą przekierowane do tych usług, mając pierwszeństwo przed publicznym wpisem DNS.
Aby temu zapobiec, ogranicz uprawnienia do tworzenia przestrzeni nazw dla zaufanych użytkowników. Jeśli to konieczne, możesz dodatkowo skonfigurować zewnętrzne mechanizmy kontroli bezpieczeństwa, takie jak [admission webhooks](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/)
, aby zablokować tworzenie jakiejkolwiek przestrzeni nazw o nazwie z listy [domen najwyższego poziomu (ang. TLD - Top-Level Domain)](https://data.iana.org/TLD/tlds-alpha-by-domain.txt)
.
Nie wszystkie obiekty znajdują się w przestrzeni nazw.[](https://kubernetes.io/pl/docs/concepts/_print/#not-all-objects-are-in-a-namespace)
--------------------------------------------------------------------------------------------------------------------------------------------
Większość zasobów Kubernetesa (np. pody, usługi, kontrolery replikacji i inne) znajduje się w jakiś przestrzeniach nazw. Jednak zasoby przestrzeni nazw nie są same w sobie w przestrzeni nazw. Zasoby niskiego poziomu, takie jak [węzły](https://kubernetes.io/docs/concepts/architecture/nodes/)
i [persistentVolumes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/)
, nie znajdują się w żadnej przestrzeni nazw.
Aby zobaczyć, które zasoby Kubernetesa znajdują się w przestrzeni nazw, a które nie:
# In a namespace
kubectl api-resources --namespaced=true
# Not in a namespace
kubectl api-resources --namespaced=false
Automatyczne etykietowanie[](https://kubernetes.io/pl/docs/concepts/_print/#automatic-labelling)
-------------------------------------------------------------------------------------------------
STATUS FUNKCJONALNOŚCI: `Kubernetes 1.22 [stable]`
Warstwa sterowania Kubernetesa ustawia niezmienną [etykietę](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels)
`kubernetes.io/metadata.name` na wszystkich przestrzeniach nazw. Wartością etykiety jest nazwa przestrzeni nazw.
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)
---------------------------------------------------------------------
* Dowiedz się więcej o [tworzeniu przestrzeni nazw](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#creating-a-new-namespace)
.
* Dowiedz się więcej o [usuwaniu przestrzeni nazw](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#deleting-a-namespace)
.
1.2.4 - Adnotatcje[](https://kubernetes.io/pl/docs/concepts/_print/#pg-93cd7a1d4e1623e2bf01afc49a5af69c)
=========================================================================================================
Możesz używać Kubernetesowych adnotacji do dołączania dodatkowych (czyli takich, które nie są wykorzystywane przy identyfikacji) metadanych do [obiektów](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/#kubernetes-objects)
. Narzędzia i biblioteki mogą odczytywać te metadane.
Dołączanie metadanych do obiektów[](https://kubernetes.io/pl/docs/concepts/_print/#attaching-metadata-to-objects)
------------------------------------------------------------------------------------------------------------------
Możesz używać etykiet (ang. labels) lub adnotacji (ang. annotations), aby dołączać metadane do obiektów Kubernetesa. Etykiety pomagają w wybieraniu obiektów i wyszukiwaniu ich zbiorów na podstawie określonych warunków. Z kolei adnotacje nie są używane do identyfikacji ani selekcji obiektów. Metadane w adnotacjach mogą mieć dowolny rozmiar i strukturę - mogą być małe lub duże, uporządkowane lub nie, i zawierać znaki niedozwolone w etykietach. Dopuszczalne jest jednoczesne użycie etykiet i adnotacji w tym samym obiekcie.
Adnotacje, podobnie jak etykiety, są mapami klucz/wartość:
"metadata": {
"annotations": {
"key1" : "value1",
"key2" : "value2"
}
}
#### Informacja:
Klucze i wartości w mapie muszą być ciągami znaków. Innymi słowy, nie można używać wartości numerycznych, logicznych, list ani innych typów ani dla kluczy, ani dla wartości.
Oto przykłady informacji, które mogą być zapisane w adnotacjach:
* Pola zarządzane przez warstwę konfiguracji deklaratywnej. Dołączanie tych pól jako adnotacji odróżnia je od wartości domyślnych ustawianych przez klientów lub serwery, oraz od pól generowanych automatycznie i pól ustawianych przez systemy automatycznego skalowania lub automatycznego dopasowywania rozmiaru.
* Informacje dotyczące kompilacji, wersji lub obrazów, takie jak znaczniki czasu, identyfikatory wersji, gałąź git, numery PR, skróty obrazów i adres rejestru.
* Referencje do zewnętrznych źródeł danych takich jak logi, metryki monitorujące, wyniki analiz czy dane audytowe.
* Informacje o bibliotece klienckiej lub narzędziu, które mogą być wykorzystane do debugowania - na przykład nazwa, wersja i dane o kompilacji.
* Informacje o pochodzeniu użytkownika, narzędzia lub systemu, takie jak adresy URL powiązanych obiektów z innych komponentów ekosystemu.
* Metadane wykorzystywane przez proste narzędzia do wdrażania zmian (rollout), takie jak zapis stanu konfiguracji lub punktów kontrolnych służących do śledzenia postępu wdrożenia.
* Numery telefonów lub pagerów osób odpowiedzialnych, lub wpisy do katalogu określające, gdzie można znaleźć te informacje, takie jak strona internetowa zespołu.
* Instrukcje od użytkownika końcowego kierowane do implementacji, mające na celu zmianę zachowania systemu lub uruchomienie niestandardowych funkcji.
Zamiast używać adnotacji, można przechowywać tego typu informacje w zewnętrznej bazie danych lub katalogu, ale to znacznie utrudniłoby tworzenie wspólnych bibliotek klienckich i narzędzi do wdrażania, zarządzania, introspekcji i tym podobnych działań.
Składnia i zestaw znaków[](https://kubernetes.io/pl/docs/concepts/_print/#syntax-and-character-set)
----------------------------------------------------------------------------------------------------
_Adnotacje_ są parami klucz/wartość. Prawidłowe klucze adnotacji mają dwa segmenty: opcjonalny prefiks oraz nazwę, oddzielone ukośnikiem (`/`). Segment nazwy jest wymagany i musi mieć maksymalnie 63 znaki, zaczynać się i kończyć znakiem alfanumerycznym (`[a-z0-9A-Z]`) oraz może zawierać myślniki (`-`), podkreślenia (`_`), kropki (`.`) i znaki alfanumeryczne pomiędzy nimi. Prefiks jest opcjonalny. Jeśli zostanie określony, prefiks musi być subdomeną DNS: serią etykiet DNS oddzielonych kropkami (`.`), nie dłuższą w sumie niż 253 znaki, zakończoną ukośnikiem (`/`).
Jeśli prefiks jest pominięty, zakłada się, że klucz adnotacji należy wyłącznie do użytkownika. Zautomatyzowane komponenty systemowe (np. `kube-scheduler`, `kube-controller-manager`, `kube-apiserver`, `kubectl` lub inna automatyzacja firm trzecich), które dodają adnotacje do obiektów końcowego użytkownika, muszą określić prefiks.
Prefiksy `kubernetes.io/` i `k8s.io/` są zarezerwowane dla podstawowych komponentów Kubernetesa.
Na przykład, oto manifest dla Poda, który posiada adnotację `imageregistry: https://hub.docker.com/` :
apiVersion: v1
kind: Pod
metadata:
name: annotations-demo
annotations:
imageregistry: "https://hub.docker.com/"
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)
---------------------------------------------------------------------
* Dowiedz się więcej o [Etykietach i Selektorach](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels/)
.
* Znajdź [Typowe etykiety, Adnotacje i Tainty (ang. Taints)](https://kubernetes.io/docs/reference/labels-annotations-taints/)
1.2.5 - Selektory pól[](https://kubernetes.io/pl/docs/concepts/_print/#pg-046c03090d47bc4b89b818dc645c3865)
============================================================================================================
Selektory pól (_Field selectors_) pozwalają na wybór [obiektów](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/#kubernetes-objects)
Kubernetesa na podstawie wartości jednego lub kilku pól zasobów. Oto kilka przykładów zapytań z użyciem selektora pól:
* `metadata.name=my-service`
* `metadata.namespace!=default`
* `status.phase=Pending`
Polecenie `kubectl` wybiera wszystkie Pody, dla których wartość pola [`status.phase`](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-phase)
to `Running`:
kubectl get pods --field-selector status.phase=Running
#### Informacja:
Selektory pól to zasadniczo _filtry_ zasobów. Domyślnie nie stosuje się żadnych selektorów/filtrów, co oznacza, że wszystkie zasoby określonego typu są wybierane. Dzięki temu zapytania `kubectl` `kubectl get pods` i `kubectl get pods --field-selector ""` są równoważne.
Obsługiwane pola[](https://kubernetes.io/pl/docs/concepts/_print/#supported-fields)
------------------------------------------------------------------------------------
Obsługiwane selektory pól różnią się w zależności od typu zasobu Kubernetesa. Wszystkie typy zasobów obsługują pola `metadata.name` oraz `metadata.namespace`. Użycie nieobsługiwanych selektorów pól skutkuje błędem. Na przykład:
kubectl get ingress --field-selector foo.bar=baz
Error from server (BadRequest): Unable to find "ingresses" that match label selector "", field selector "foo.bar=baz": "foo.bar" is not a known field selector: only "metadata.name", "metadata.namespace"
### Lista obsługiwanych pól[](https://kubernetes.io/pl/docs/concepts/_print/#list-of-supported-fields)
| Rodzaj | Pola |
| --- | --- |
| Pod | `spec.nodeName` `spec.restartPolicy` `spec.schedulerName` `spec.serviceAccountName` `spec.hostNetwork` `status.phase` `status.podIP` `status.podIPs` `status.nominatedNodeName` |
| Event | `involvedObject.kind` `involvedObject.namespace` `involvedObject.name` `involvedObject.uid` `involvedObject.apiVersion` `involvedObject.resourceVersion` `involvedObject.fieldPath` `reason` `reportingComponent` `source` `type` |
| Secret | `type` |
| Namespace | `status.phase` |
| ReplicaSet | `status.replicas` |
| ReplicationController | `status.replicas` |
| Job | `status.successful` |
| Node | `spec.unschedulable` |
| CertificateSigningRequest | `spec.signerName` |
### Pola zasobów niestandardowych[](https://kubernetes.io/pl/docs/concepts/_print/#custom-resources-fields)
Wszystkie niestandardowe typy zasobów obsługują pola `metadata.name` oraz `metadata.namespace`.
Dodatkowo, pole `spec.versions[*].selectableFields` w [CustomResourceDefinition](https://kubernetes.io/pl/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/)
określa, które inne pola w zasobie niestandardowym mogą być używane w selektorach pól. Zobacz [selectable fields for custom resources](https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#crd-selectable-fields)
aby uzyskać więcej informacji o tym, jak używać selektorów pól z CustomResourceDefinitions.
Obsługiwane operatory[](https://kubernetes.io/pl/docs/concepts/_print/#supported-operators)
--------------------------------------------------------------------------------------------
Możesz używać operatorów `=`, `==` i `!=` z selektorami pól (`=` and `==` oznaczają to samo). Na przykład ta komenda `kubectl` wybiera wszystkie usługi Kubernetesa, które nie znajdują się w przestrzeni nazw `default`:
kubectl get services --all-namespaces --field-selector metadata.namespace!=default
#### Informacja:
Operatory dla zbiorów ([Set-based operators](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels/#set-based-requirement)
) (`in`, `notin`, `exists`) nie są obsługiwane dla selektorów pól.
Złożone selektory[](https://kubernetes.io/pl/docs/concepts/_print/#chained-selectors)
--------------------------------------------------------------------------------------
Podobnie jak [etykieta](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/labels/)
i inne selektory, selektory pól mogą być łączone w postaci listy rozdzielanej przecinkami. To polecenie `kubectl` wybiera wszystkie Pody, dla których `status.phase` nie jest równe `Running`, a pole `spec.restartPolicy` jest równe `Always`:
kubectl get pods --field-selector=status.phase!=Running,spec.restartPolicy=Always
Wiele typów zasobów[](https://kubernetes.io/pl/docs/concepts/_print/#multiple-resource-types)
----------------------------------------------------------------------------------------------
Możesz używać selektorów pól w różnych typach zasobów. To polecenie `kubectl` wybiera wszystkie obiekty typu Statefulset i Service, które nie znajdują się w przestrzeni nazw `default`:
kubectl get statefulsets,services --all-namespaces --field-selector metadata.namespace!=default
1.2.6 - Zalecane etykiety[](https://kubernetes.io/pl/docs/concepts/_print/#pg-5dd62c6a4a481b4cf1ac50f6799eb581)
================================================================================================================
Możesz wizualizować i zarządzać obiektami Kubernetesa za pomocą większej liczby narzędzi niż tylko kubectl i dashboard. Wspólny zestaw etykiet umożliwia narzędziom współpracę, opisując obiekty w ujednolicony sposób, który wszystkie narzędzia mogą zrozumieć.
Poza wsparciem dla narzędzi, rekomendowane etykiety opisują aplikacje tak, aby można było je łatwo wyszukiwać za pomocą zapytań.
Metadane są zorganizowane wokół pojęcia _aplikacji_. Kubernetes nie jest platformą typu PaaS i nie posiada ani nie wymusza formalnej definicji aplikacji. Zamiast tego aplikacje mają charakter nieformalny i są opisywane za pomocą metadanych. Definicja tego, co wchodzi w skład aplikacji, jest dość luźna.
#### Informacja:
Są to zalecane etykiety. Ułatwiają zarządzanie aplikacjami, ale nie są wymagane do działania podstawowych narzędzi.
Współdzielone etykiety i adnotacje mają prefiks: `app.kubernetes.io`. Etykiety bez prefiksu są traktowane jako prywatne. Dzięki temu prefiksowi etykiety współdzielone nie kolidują z etykietami definiowanymi przez użytkownika.
Etykiety[](https://kubernetes.io/pl/docs/concepts/_print/#labels)
------------------------------------------------------------------
Aby w pełni wykorzystać zalety etykiet, warto dodawać je do każdego obiektu w systemie.
| Klucz | Opis | Przykład | Typ |
| --- | --- | --- | --- |
| `app.kubernetes.io/name` | Nazwa aplikacji | `mysql` | string |
| `app.kubernetes.io/instance` | Unikalna nazwa identyfikująca instancję aplikacji | `mysql-abcxyz` | string |
| `app.kubernetes.io/version` | Aktualna wersja aplikacji (np. [SemVer 1.0](https://semver.org/spec/v1.0.0.html) , hash rewizji, itp.) | `5.7.21` | ciąg znaków |
| `app.kubernetes.io/component` | Komponent w ramach architektury | `baza danych` | string |
| `app.kubernetes.io/part-of` | Nazwa nadrzędnej aplikacji, do której należy ten element | `wordpress` | string |
| `app.kubernetes.io/managed-by` | Narzędzie używane do zarządzania operacjami aplikacji | `Helm` | string |
Aby zilustrować działanie tych etykiet, rozważ następujący obiekt [StatefulSet](https://kubernetes.io/pl/docs/concepts/workloads/controllers/statefulset/)
:
# This is an excerpt
apiVersion: apps/v1
kind: StatefulSet
metadata:
labels:
app.kubernetes.io/name: mysql
app.kubernetes.io/instance: mysql-abcxyz
app.kubernetes.io/version: "5.7.21"
app.kubernetes.io/component: database
app.kubernetes.io/part-of: wordpress
app.kubernetes.io/managed-by: Helm
Aplikacje i instancje aplikacji[](https://kubernetes.io/pl/docs/concepts/_print/#applications-and-instances-of-applications)
-----------------------------------------------------------------------------------------------------------------------------
Aplikacja może być zainstalowana jeden lub więcej razy w klastrze Kubernetesa, a w niektórych przypadkach w tej samej przestrzeni nazw. Na przykład WordPress może być zainstalowany więcej niż raz, gdzie różne strony internetowe to różne instalacje WordPressa.
Nazwa aplikacji i nazwa instancji są rejestrowane oddzielnie. Na przykład, WordPress ma `app.kubernetes.io/name` o wartości `wordpress`, natomiast nazwa instancji jest reprezentowana jako `app.kubernetes.io/instance` z wartością `wordpress-abcxyz`. Umożliwia to identyfikację aplikacji oraz jej instancji. Każda instancja aplikacji musi mieć unikalną nazwę.
Przykłady[](https://kubernetes.io/pl/docs/concepts/_print/#examples)
---------------------------------------------------------------------
Aby zilustrować różne sposoby wykorzystania tych etykiet, poniższe przykłady mają różny stopień złożoności.
### Prosta usługa bezstanowa (ang. Stateless Service)[](https://kubernetes.io/pl/docs/concepts/_print/#a-simple-stateless-service)
Rozważmy przypadek prostego serwisu bezstanowego wdrożonego przy użyciu obiektów `Deployment` i `Service`. Poniższe dwa fragmenty przedstawiają, jak etykiety mogą być używane w najprostszej formie.
`Deployment` jest używany do nadzorowania podów uruchamiających samą aplikację.
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: myservice
app.kubernetes.io/instance: myservice-abcxyz
...
`Service` służy do udostępniania aplikacji.
apiVersion: v1
kind: Service
metadata:
labels:
app.kubernetes.io/name: myservice
app.kubernetes.io/instance: myservice-abcxyz
...
### Aplikacja webowa z bazą danych[](https://kubernetes.io/pl/docs/concepts/_print/#web-application-with-a-database)
Rozważmy nieco bardziej skomplikowaną aplikację: aplikację webową (WordPress) korzystającą z bazy danych (MySQL), zainstalowaną za pomocą Helm. Poniższe fragmenty ilustrują początek obiektów użytych do wdrożenia tej aplikacji.
Początek następującego `Deployment` jest używany dla WordPressa:
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app.kubernetes.io/name: wordpress
app.kubernetes.io/instance: wordpress-abcxyz
app.kubernetes.io/version: "4.9.4"
app.kubernetes.io/managed-by: Helm
app.kubernetes.io/component: server
app.kubernetes.io/part-of: wordpress
...
`Service` jest używany do udostępniania WordPressa:
apiVersion: v1
kind: Service
metadata:
labels:
app.kubernetes.io/name: wordpress
app.kubernetes.io/instance: wordpress-abcxyz
app.kubernetes.io/version: "4.9.4"
app.kubernetes.io/managed-by: Helm
app.kubernetes.io/component: server
app.kubernetes.io/part-of: wordpress
...
MySQL jest udostępniany jako `StatefulSet` z metadanymi zarówno dla niego, jak i dla nadrzędnej aplikacji, do której należy:
apiVersion: apps/v1
kind: StatefulSet
metadata:
labels:
app.kubernetes.io/name: mysql
app.kubernetes.io/instance: mysql-abcxyz
app.kubernetes.io/version: "5.7.21"
app.kubernetes.io/managed-by: Helm
app.kubernetes.io/component: database
app.kubernetes.io/part-of: wordpress
...
`Serwis` jest używany do udostępniania MySQL jako część WordPressa:
apiVersion: v1
kind: Service
metadata:
labels:
app.kubernetes.io/name: mysql
app.kubernetes.io/instance: mysql-abcxyz
app.kubernetes.io/version: "5.7.21"
app.kubernetes.io/managed-by: Helm
app.kubernetes.io/component: database
app.kubernetes.io/part-of: wordpress
...
W `StatefulSet` i `Service` dla MySQL zawarte są informacje zarówno o MySQL, jak i o WordPressie, czyli nadrzędnej aplikacji.
1.3 - API Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#pg-0c745f42e623d2b70a53bc0e6db73d95)
============================================================================================================
API Kubernetesa służy do odpytywania i zmiany stanu obiektów Kubernetesa. Sercem warstwy sterowania Kubernetesa jest serwer API i udostępniane po HTTP API. Przez ten serwer odbywa się komunikacja pomiędzy użytkownikami, różnymi częściami składowymi klastra oraz komponentami zewnętrznymi.
Sercem [warstwy sterowania](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-control-plane)
Kubernetesa jest [serwer API](https://kubernetes.io/pl/docs/concepts/architecture/#kube-apiserver)
. Serwer udostępnia API poprzez HTTP, umożliwiając wzajemną komunikację pomiędzy użytkownikami, częściami składowymi klastra i komponentami zewnętrznymi.
API Kubernetesa pozwala na sprawdzanie i zmianę stanu obiektów (przykładowo: pody, _Namespaces_, _ConfigMaps_, _Events_).
Większość operacji może zostać wykonana poprzez interfejs linii komend (CLI) [kubectl](https://kubernetes.io/docs/reference/kubectl/)
lub inne programy, takie jak [kubeadm](https://kubernetes.io/docs/reference/setup-tools/kubeadm/)
, które używają API. Możesz też korzystać z API bezpośrednio przez wywołania typu REST. Jeśli piszesz aplikację używającą API Kubernetesa, warto rozważyć użycie jednej z [bibliotek klienckich](https://kubernetes.io/docs/reference/using-api/client-libraries/)
.
Każdy klaster Kubernetesa publikuje specyfikację dostępnych interfejsów API. Dostępne są dwa mechanizmy udostępniania tych specyfikacji, które umożliwiają automatyczną integrację i interoperacyjność z narzędziami zewnętrznymi. Na przykład narzędzie `kubectl` pobiera i buforuje specyfikację API w celu umożliwienia autouzupełniania wiersza poleceń i innych funkcji. Te dwa mechanizmy to:
* [Discovery API](https://kubernetes.io/pl/docs/concepts/_print/#discovery-api)
dostarcza informacji o interfejsach API Kubernetesa: nazwach API, zasobach, wersjach i obsługiwanych operacjach. W Kubernetesie ten termin ma szczególne znaczenie, ponieważ to odrębny interfejs od OpenAPI i jest traktowany jako osobna część systemu. Jest to zwięzłe podsumowanie dostępnych zasobów i nie obejmuje szczegółowych definicji schematów. Szczegółowe informacje o strukturze zasobów można znaleźć w dokumencie OpenAPI.
* [Kubernetes OpenAPI Document](https://kubernetes.io/pl/docs/concepts/_print/#openapi-interface-definition)
dostarcza (pełne) [schematy OpenAPI v2.0 i 3.0](https://www.openapis.org/)
dla wszystkich endpointów API Kubernetesa. OpenAPI v3 to zalecany sposób uzyskiwania dostępu do specyfikacji API, ponieważ zapewnia pełniejszy i dokładniejszy obraz. Zawiera wszystkie ścieżki API oraz komplet danych wejściowych i wyjściowych dla każdej operacji na wszystkich endpointach. Specyfikacja obejmuje także wszystkie rozszerzenia wspierane przez klaster. Jest to pełna definicja API, która znacząco przewyższa pod względem szczegółowości dane z Discovery API.
Discovery API[](https://kubernetes.io/pl/docs/concepts/_print/#discovery-api)
------------------------------------------------------------------------------
Kubernetes przez Discovery API udostępnia pełną listę obsługiwanych grup API, ich wersji oraz zasobów. Dla każdego zasobu można uzyskać następujące dane:
* Nazwa
* Klaster lub zasięg w przestrzeni nazw
* URL endpointu oraz obsługiwane metody HTTP
* Alternatywne nazwy
* Grupa, wersja, typ
API jest dostępne zarówno w formie zagregowanej, jak i niezagregowanej. W trybie zagregowanym Discovery API udostępnia dwa endpointy, natomiast w trybie niezagregowanym jest to oddzielny endpoint dla każdej wersji grupy.
### Zagregowane Discovery API[](https://kubernetes.io/pl/docs/concepts/_print/#aggregated-discovery)
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.30 [stable]`(domyślnie włączone)
Kubernetes zapewnia stabilne wsparcie dla zagregowanego Discovery API, publikując wszystkie zasoby obsługiwane przez klaster za pośrednictwem dwóch endpointów (`/api` i `/apis`). Korzystanie z tych endpointów znacząco ogranicza liczbę zapytań potrzebnych do pobrania danych z klastra. Dostęp do tych danych uzyskuje się, wysyłając żądanie na odpowiedni endpoint z nagłówkiem `Accept`, który wskazuje na zagregowany zasób Discovery: `Accept: application/json;v=v2;g=apidiscovery.k8s.io;as=APIGroupDiscoveryList`.
W przypadku braku nagłówka `Accept` wskazującego typ zasobu, zapytania do endpointów `/api` i `/apis` zwracają domyślnie dane w formacie niezagregowanym.
[Discovery document](https://github.com/kubernetes/kubernetes/blob/release-1.35/api/discovery/aggregated_v2.json)
znajduje się w oficjalnym repozytorium GitHub Kubernetesa. Może on służyć jako odniesienie do podstawowego zestawu zasobów dostępnych w Kubernetesie, gdy nie masz możliwości wykonania zapytania do rzeczywistego klastra.
Endpoint obsługuje także mechanizm ETag oraz możliwość przesyłania danych w formacie protobuf.
### Niezagregowane Discovery API[](https://kubernetes.io/pl/docs/concepts/_print/#unaggregated-discovery)
W przypadku braku agregacji Discovery API, dane udostępniane są w strukturze wielopoziomowej, w której główne endpointy publikują informacje prowadzące do podrzędnych dokumentów.
Wszystkie wersje grup API dostępnych w klastrze są udostępniane pod endpointami /api i /apis. Oto przykład:
{
"kind": "APIGroupList",
"apiVersion": "v1",
"groups": [\
{\
"name": "apiregistration.k8s.io",\
"versions": [\
{\
"groupVersion": "apiregistration.k8s.io/v1",\
"version": "v1"\
}\
],\
"preferredVersion": {\
"groupVersion": "apiregistration.k8s.io/v1",\
"version": "v1"\
}\
},\
{\
"name": "apps",\
"versions": [\
{\
"groupVersion": "apps/v1",\
"version": "v1"\
}\
],\
"preferredVersion": {\
"groupVersion": "apps/v1",\
"version": "v1"\
}\
},\
...\
}\
\
\
Żeby pobrać informacje o zasobach dostępnych w konkretnej wersji API, trzeba wysłać osobne zapytanie pod `/apis//` - np. `/apis/rbac.authorization.k8s.io/v1alpha1`. Ten endpoint zawiera listę typów zasobów w danej grupie. Używa go polecenie kubectl, żeby dowiedzieć się, jakie zasoby są dostępne w klastrze.\
\
Interfejs OpenAPI[](https://kubernetes.io/pl/docs/concepts/_print/#openapi-interface-definition)\
\
-------------------------------------------------------------------------------------------------\
\
Pełną specyfikację API udokumentowano za pomocą [OpenAPI](https://www.openapis.org/)\
.\
\
Kubernetes obsługuje zarówno OpenAPI 2.0, jak i 3.0. Wersja 3 jest preferowana, ponieważ umożliwia dokładniejszy i kompletny opis zasobów (bez utraty informacji). W OpenAPI 2 niektóre pola, np. `default`, `nullable`, `oneOf`, są pomijane z powodu ograniczeń formatu.\
\
### OpenAPI V2[](https://kubernetes.io/pl/docs/concepts/_print/#openapi-v2)\
\
Serwer API Kubernetesa udostępnia specyfikację OpenAPI poprzez ścieżkę `/openapi/v2`. Aby wybrać format odpowiedzi, użyj nagłówków żądania zgodnie z tabelą:\
\
| | | |\
| --- | --- | --- |Dopuszczalne wartości nagłówka żądania dla zapytań OpenAPI v2\
| Nagłówek | Dopuszczalne wartości | Uwagi |\
| --- | --- | --- |\
| `Accept-Encoding` | `gzip` | _pominięcie tego nagłówka jest dozwolone_ |\
| `Accept` | `application/com.github.proto-openapi.spec.v2@v1.0+protobuf` | _głównie do celu komunikacji wewnątrz klastra_ |\
| `application/json` | _domyślne_ |\
| `*` | _udostępnia_ `application/json` |\
\
#### Ostrzeżenie:\
\
Reguły walidacyjne publikowane w ramach schematów OpenAPI mogą być niekompletne – i zazwyczaj nie zawierają wszystkich warunków. Dodatkowa walidacja realizowana jest przez serwer API. Aby uzyskać pełną i precyzyjną weryfikację, zaleca się użycie polecenia `kubectl apply --dry-run=server`, które uruchamia wszystkie mechanizmy walidacji, również te wykonujące się podczas przyjmowania zasobów do klastra (ang. admission checks).\
\
### OpenAPI V3[](https://kubernetes.io/pl/docs/concepts/_print/#openapi-v3)\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.27 [stable]`(domyślnie włączone)\
\
Kubernetes publikuje własne API zgodnie ze specyfikacją OpenAPI v3.\
\
Pod adresem `/openapi/v3` można znaleźć listę wszystkich dostępnych grup/wersji. Zwracane wartości są dostępne tylko w formacie JSON. Grupy/wersje opisane są następującym schematem:\
\
{\
"paths": {\
...,\
"api/v1": {\
"serverRelativeURL": "/openapi/v3/api/v1?hash=CC0E9BFD992D8C59AEC98A1E2336F899E8318D3CF4C68944C3DEC640AF5AB52D864AC50DAA8D145B3494F75FA3CFF939FCBDDA431DAD3CA79738B297795818CF"\
},\
"apis/admissionregistration.k8s.io/v1": {\
"serverRelativeURL": "/openapi/v3/apis/admissionregistration.k8s.io/v1?hash=E19CC93A116982CE5422FC42B590A8AFAD92CDE9AE4D59B5CAAD568F083AD07946E6CB5817531680BCE6E215C16973CD39003B0425F3477CFD854E89A9DB6597"\
},\
....\
}\
}\
\
\
Względne adresy URL wskazują na niezmieniające się opisy OpenAPI, aby umożliwić trzymanie cache po stronie klienta. Serwer API zwraca również odpowiednie nagłówki HTTP dla cache (`Expires` ustawione na 1 rok wprzód, `Cache-Control` jako `immutable`). Wysłanie zapytania do nieaktualnego URL spowoduje przekierowanie przez serwer API do wersji najnowszej.\
\
Serwer API Kubernetesa udostępnia specyfikację OpenAPI v3 pod adresem `/openapi/v3/apis//?hash=`, zgodnie z podziałem na grupy i wersje.\
\
Tabela poniżej podaje dopuszczalne wartości nagłówków żądania.\
\
| | | |\
| --- | --- | --- |Dopuszczalne wartości nagłówka żądania dla zapytań OpenAPI v3\
| Nagłówek | Dopuszczalne wartości | Uwagi |\
| --- | --- | --- |\
| `Accept-Encoding` | `gzip` | _pominięcie tego nagłówka jest dozwolone_ |\
| `Accept` | `application/com.github.proto-openapi.spec.v3@v1.0+protobuf` | _głównie do celu komunikacji wewnątrz klastra_ |\
| `application/json` | _domyślne_ |\
| `*` | _udostępnia_ `application/json` |\
\
W pakiecie [`k8s.io/client-go/openapi3`](https://pkg.go.dev/k8s.io/client-go/openapi3)\
znajduje się implementacja w Golang do pobierania OpenAPI V3.\
\
Kubernetes 1.35 publikuje OpenAPI w wersji 2.0 i 3.0; nie ma planów wsparcia wersji 3.1 w najbliższej przyszłości.\
\
### Serializacja Protobuf[](https://kubernetes.io/pl/docs/concepts/_print/#protobuf-serialization)\
\
Kubernetes implementuje alternatywny format serializacji oparty na Protobuf, który jest głównie przeznaczony do komunikacji w obrębie klastra. Aby uzyskać więcej informacji na temat tego formatu, zobacz [Kubernetes Protobuf serialization](https://git.k8s.io/design-proposals-archive/api-machinery/protobuf.md)\
propozycję projektową oraz pliki Interface Definition Language (IDL) dla każdego schematu znajdujące się w pakietach Go, które definiują obiekty API.\
\
Przechowywanie stanu[](https://kubernetes.io/pl/docs/concepts/_print/#persistence)\
\
-----------------------------------------------------------------------------------\
\
Kubernetes przechowuje serializowany stan swoich obiektów w [etcd](https://kubernetes.io/pl/docs/tasks/administer-cluster/configure-upgrade-etcd/)\
.\
\
Grupy i wersje API[](https://kubernetes.io/pl/docs/concepts/_print/#api-groups-and-versioning)\
\
-----------------------------------------------------------------------------------------------\
\
Aby ułatwić usuwanie poszczególnych pól lub restrukturyzację reprezentacji zasobów, Kubernetes obsługuje równocześnie wiele wersji API, każde poprzez osobną ścieżkę API, na przykład: `/api/v1` lub `/apis/rbac.authorization.k8s.io/v1alpha1`.\
\
Rozdział wersji wprowadzony jest na poziomie całego API, a nie na poziomach poszczególnych zasobów lub pól, aby być pewnym, że API odzwierciedla w sposób przejrzysty i spójny zasoby systemowe i ich zachowania oraz pozwala na kontrolowany dostęp do tych API, które są w fazie wycofywania lub fazie eksperymentalnej.\
\
Aby ułatwić rozbudowę API Kubernetes, wprowadziliśmy [_grupy API_](https://git.k8s.io/community/contributors/design-proposals/api-machinery/api-group.md)\
, które mogą być [włączane i wyłączane](https://kubernetes.io/docs/reference/using-api/#enabling-or-disabling)\
.\
\
Zasoby API są rozróżniane poprzez przynależność do grupy API, typ zasobu, przestrzeń nazw (_namespace_, o ile ma zastosowanie) oraz nazwę. Serwer API może przeprowadzać konwersję między różnymi wersjami API w sposób niewidoczny dla użytkownika: wszystkie te różne wersje reprezentują w rzeczywistości ten sam zasób. Serwer API może udostępniać te same dane poprzez kilka różnych wersji API.\
\
Załóżmy przykładowo, że istnieją dwie wersje `v1` i `v1beta1` tego samego zasobu. Obiekt utworzony przez wersję `v1beta1` może być odczytany, zaktualizowany i skasowany zarówno przez wersję `v1beta1`, jak i `v1`, do czasu aż wersja `v1beta1` będzie przestarzała i usunięta. Wtedy możesz dalej korzystać i modyfikować obiekt poprzez wersję `v1`.\
\
### Zmiany w API[](https://kubernetes.io/pl/docs/concepts/_print/#api-changes)\
\
Z naszego doświadczenia wynika, że każdy system, który odniósł sukces, musi się nieustająco rozwijać w miarę zmieniających się potrzeb. Dlatego Kubernetes został tak zaprojektowany, aby API mogło się zmieniać i rozrastać. Projekt Kubernetes dąży do tego, aby nie wprowadzać zmian niezgodnych z istniejącymi aplikacjami klienckimi i utrzymywać zgodność przez wystarczająco długi czas, aby inne projekty zdążyły się dostosować do zmian.\
\
W ogólności, nowe zasoby i pola definiujące zasoby API są dodawane stosunkowo często. Usuwanie zasobów lub pól jest regulowane przez [API deprecation policy](https://kubernetes.io/docs/reference/using-api/deprecation-policy/)\
.\
\
Po osiągnięciu przez API statusu ogólnej dostępności (_general availability_ - GA), oznaczanej zazwyczaj jako wersja API `v1`, bardzo zależy nam na utrzymaniu jej zgodności w kolejnych wydaniach. Dodatkowo, Kubernetes zachowuje kompatybilność z danymi zapisanymi za pomocą wersji _beta_. Gdy dana funkcja osiąga stabilność (GA), dane te mogą być automatycznie konwertowane i dostępne w docelowej wersji API.\
\
Jeśli korzystasz z wersji beta API, musisz przejść na kolejną wersję beta lub stabilną, gdy dana wersja zostanie wycofana. Najlepszy moment na migrację to okres wycofywania wersji beta - wtedy obiekty są dostępne równocześnie w obu wersjach API. Po zakończeniu tego okresu wersja beta przestaje być obsługiwana i konieczne jest użycie wersji docelowej.\
\
#### Informacja:\
\
Mimo, że Kubernetes stara się także zachować zgodność dla API w wersji _alpha_, zdarzają się przypadki, kiedy nie jest to możliwe. Jeśli korzystasz z API w wersji alfa, przed aktualizacją klastra do nowej wersji zalecamy sprawdzenie w informacjach o wydaniu, czy nie nastąpiła jakaś zmiana w tej części API. Może się okazać, że API uległo niekompatybilnym zmianom, co wymaga usunięcia wszystkich istniejących obiektów alfa przed wykonaniem aktualizacji.\
\
Zajrzyj do [API versions reference](https://kubernetes.io/docs/reference/using-api/#api-versioning)\
po szczegółowe definicje różnych poziomów wersji API.\
\
Rozbudowa API[](https://kubernetes.io/pl/docs/concepts/_print/#api-extension)\
\
------------------------------------------------------------------------------\
\
API Kubernetesa można rozszerzać na dwa sposoby:\
\
1. [Definicje zasobów własnych (_custom resources_)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)\
pozwalają deklaratywnie określać, jak serwer API powinien dostarczać wybrane przez Ciebie zasoby API.\
2. Można także rozszerzać API Kubernetesa implementując [warstwę agregacji](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/)\
.\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
* Naucz się, jak rozbudowywać API Kubernetesa poprzez dodawanie własnych [CustomResourceDefinition](https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/)\
.\
* [Controlling Access To The Kubernetes API](https://kubernetes.io/docs/concepts/security/controlling-access/)\
opisuje sposoby, jakimi klaster zarządza dostępem do API.\
* Punkty dostępowe API _(endpoints)_, typy zasobów i przykłady zamieszczono w [API Reference](https://kubernetes.io/docs/reference/kubernetes-api/)\
.\
* Aby dowiedzieć się, jaki rodzaj zmian można określić jako zgodne i jak zmieniać API, zajrzyj do [API changes](https://git.k8s.io/community/contributors/devel/sig-architecture/api_changes.md#readme)\
.\
\
2 - Architektura klastra[](https://kubernetes.io/pl/docs/concepts/_print/#pg-2bf36ccd6b3dbeafecf87c39761b07c7)\
\
===============================================================================================================\
\
Podstawowe założenia architektury Kubernetesa.\
\
Klaster Kubernetesa składa się z warstwy sterowania oraz zestawu maszyn roboczych, zwanych węzłami, które uruchamiają konteneryzowane aplikacje. Każdy klaster potrzebuje co najmniej jednego węzła roboczego, aby obsługiwać Pody.\
\
Węzeł roboczy hostuje Pody, które są komponentami _workload_ aplikacji. Warstwa sterowania zarządza węzłami roboczymi oraz Podami w klastrze. W środowiskach produkcyjnych, warstwa sterowania zazwyczaj działa na wielu komputerach, a klaster zazwyczaj działa na wielu węzłach, zapewniając odporność na awarie i wysoką dostępność.\
\
Ten dokument opisuje różne komponenty, które musisz posiadać, aby mieć kompletny i działający klaster Kubernetesa.\
\
\
\
Rysunek 1. Komponenty klastra Kubernetesa.\
\
About this architecture\
\
Diagram na Rysunku 1 przedstawia przykładową referencyjną architekturę klastra Kubernetesa. Rzeczywisty rozkład komponentów może różnić się w zależności od specyficznych konfiguracji klastra i wymagań.\
\
Na schemacie każdy węzeł uruchamia komponent [`kube-proxy`](https://kubernetes.io/pl/docs/concepts/_print/#kube-proxy)\
. Potrzebujesz komponentu sieciowego proxy na każdym węźle, aby zapewnić, że API [Service](https://kubernetes.io/pl/docs/concepts/services-networking/service/)\
i związane z nim zachowania są dostępne w sieci klastra. Niektóre wtyczki sieciowe jednak dostarczają własne, zewnętrzne implementacje proxy. Kiedy korzystasz z tego rodzaju wtyczki sieciowej, węzeł nie musi uruchamiać `kube-proxy`.\
\
Komponenty warstwy sterowania[](https://kubernetes.io/pl/docs/concepts/_print/#control-plane-components)\
\
---------------------------------------------------------------------------------------------------------\
\
Komponenty warstwy sterowania podejmują globalne decyzje dotyczące klastra (na przykład harmonogramowanie), a także wykrywają i reagują na zdarzenia klastra (na przykład uruchamianie nowego [poda](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
gdy nie zgadza się liczba `[replik](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-replica) ` Deploymentu.\
\
Elementy warstwy sterowania mogą być uruchamiane na dowolnej maszynie w klastrze. Jednakże, dla uproszczenia, skrypty instalacyjne zazwyczaj uruchamiają wszystkie elementy warstwy sterowania na tej samej maszynie i nie uruchamiają kontenerów użytkownika na tej maszynie. Zobacz [Tworzenie klastrów o wysokiej dostępności za pomocą kubeadm](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability/)\
dla przykładowej konfiguracji warstwy sterowania, która działa na wielu maszynach.\
\
### kube-apiserver[](https://kubernetes.io/pl/docs/concepts/_print/#kube-apiserver)\
\
Serwer API jest składnikiem [warstwy sterowania](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-control-plane)\
Kubernetesa, który udostępnia API. Server API służy jako front-end warstwy sterowania Kubernetesa.\
\
Podstawową implementacją serwera API Kubernetesa jest [kube-apiserver](https://kubernetes.io/docs/reference/generated/kube-apiserver/)\
. kube-apiserver został zaprojektowany w taki sposób, aby móc skalować się horyzontalnie — to oznacza, że zwiększa swoją wydajność poprzez dodawanie kolejnych instancji. Można uruchomić kilka instancji kube-apiserver i rozkładać między nimi ruch od klientów.\
\
### etcd[](https://kubernetes.io/pl/docs/concepts/_print/#etcd)\
\
Magazyn typu klucz-wartość _(key/value store)_, zapewniający spójność i wysoką dostępność, używany do przechowywania wszystkich danych o klastrze Kubernetesa.\
\
Jeśli Twój klaster Kubernetesa używa etcd do przechowywania swoich danych, upewnij się, że masz opracowany plan tworzenia [kopii zapasowych](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/#backing-up-an-etcd-cluster)\
tych danych.\
\
Szczegółowe informacje na temat etcd można znaleźć w oficjalnej [dokumentacji](https://etcd.io/docs/)\
.\
\
### kube-scheduler[](https://kubernetes.io/pl/docs/concepts/_print/#kube-scheduler)\
\
Składnik warstwy sterowania, który śledzi tworzenie nowych [podów](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
i przypisuje im [węzły](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
, na których powinny zostać uruchomione.\
\
Przy podejmowaniu decyzji o wyborze węzła brane pod uwagę są wymagania indywidualne i zbiorcze odnośnie [zasobów](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-infrastructure-resource)\
, ograniczenia wynikające z polityk sprzętu i oprogramowania, wymagania _affinity_ i _anty-affinity_, lokalizacja danych, zależności między zadaniami i wymagania czasowe.\
\
### kube-controller-manager[](https://kubernetes.io/pl/docs/concepts/_print/#kube-controller-manager)\
\
Składnik warstwy sterowania odpowiedzialny za uruchamianie [kontrolerów](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
.\
\
Z poziomu podziału logicznego, każdy [kontroler](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
jest oddzielnym procesem, ale w celu zmniejszenia złożoności, wszystkie kontrolery są skompilowane do jednego programu binarnego i uruchamiane jako jeden proces.\
\
Istnieje wiele różnych typów kontrolerów. Niektóre z nich to:\
\
* Kontroler węzłów (ang. Node controller): Odpowiada za zauważanie i reagowanie, gdy węzły przestają działać.\
* Kontroler zadania (ang. Job controller): Monitoruje obiekty zadania (Job), które reprezentują jednorazowe zadania, a następnie tworzy Pody, aby wykonały te zadania do końca.\
* Kontroler EndpointSlice: Uzupełnia obiekty EndpointSlice (aby zapewnić połączenie między Services a Pods).\
* Kontroler ServiceAccount: Tworzenie domyślnych obiektów ServiceAccount dla nowych przestrzeni nazw.\
\
Powyższa lista nie jest wyczerpującą.\
\
### cloud-controller-manager[](https://kubernetes.io/pl/docs/concepts/_print/#cloud-controller-manager)\
\
Element składowy [warstwy sterowania](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-control-plane)\
Kubernetesa, który zarządza usługami realizowanymi po stronie chmur obliczeniowych. Cloud controller manager umożliwia połączenie Twojego klastra z API operatora usług chmurowych i rozdziela składniki operujące na platformie chmurowej od tych, które dotyczą wyłącznie samego klastra.\
\
Manager 'cloud-controller' uruchamia tylko kontrolery specyficzne dla dostawcy chmury. Jeśli uruchamiasz Kubernetesa w swojej siedzibie lub w środowisku do nauki na swoim komputerze osobistym, klaster nie posiada managera 'cloud-controller'.\
\
Podobnie jak kube-controller-manager, cloud-controller-manager łączy kilka logicznie niezależnych pętli kontrolnych w jedną binarkę, którą uruchamiasz jako pojedynczy proces. Możesz go skalować horyzontalnie (uruchamiając więcej niż jedną kopię), aby poprawić wydajność lub pomóc w tolerowaniu awarii.\
\
Następujące kontrolery mogą mieć zależności od dostawcy chmury:\
\
* Kontroler węzłów (ang. Node controller): Do sprawdzania dostawcy chmury w celu ustalenia, czy węzeł został usunięty w chmurze po tym, jak przestaje odpowiadać.\
* Kontroler tras (ang. Route controller): Do konfiguracji tras w podstawowej infrastrukturze chmurowej.\
* Kontroler usługi (ang. Service controller): Do tworzenia, aktualizowania i usuwania load balancerów dostawcy chmury.\
\
* * *\
\
Komponenty węzła[](https://kubernetes.io/pl/docs/concepts/_print/#node-components)\
\
-----------------------------------------------------------------------------------\
\
Komponenty węzła działają na każdym węźle, utrzymując działające pody i zapewniając środowisko wykonawcze Kubernetesa.\
\
### kubelet[](https://kubernetes.io/pl/docs/concepts/_print/#kubelet)\
\
Agent, który działa na każdym [węźle](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
klastra. Odpowiada za uruchamianie [kontenerów](https://kubernetes.io/pl/docs/concepts/containers/)\
w ramach [poda](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
.\
\
[kubelet](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)\
korzysta z dostarczanych (różnymi metodami) _PodSpecs_ i gwarantuje, że kontenery opisane przez te PodSpecs są uruchomione i działają poprawnie. Kubelet nie zarządza kontenerami, które nie zostały utworzone przez Kubernetesa.\
\
### `kube-proxy` (opcjonalne)[](https://kubernetes.io/pl/docs/concepts/_print/#kube-proxy)\
\
kube-proxy to _proxy_ sieciowe, które uruchomione jest na każdym [węźle](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
klastra i uczestniczy w tworzeniu [serwisu](https://kubernetes.io/pl/docs/concepts/services-networking/service/)\
.\
\
[kube-proxy](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/)\
utrzymuje reguły sieciowe na węźle. Dzięki tym regułom sieci na zewnątrz i wewnątrz klastra mogą komunikować się z podami.\
\
kube-proxy używa warstwy filtrowania pakietów dostarczanych przez system operacyjny, o ile taka jest dostępna. W przeciwnym przypadku, kube-proxy samo zajmuje sie przekazywaniem ruchu sieciowego.\
\
Jeśli używasz [wtyczki sieciowej](https://kubernetes.io/pl/docs/concepts/_print/#network-plugins)\
, która samodzielnie implementuje przekazywanie pakietów dla Usług i zapewnia równoważne działanie do kube-proxy, to nie musisz uruchamiać kube-proxy na węzłach w swoim klastrze.\
\
### Środowisko uruchomieniowe kontenera[](https://kubernetes.io/pl/docs/concepts/_print/#container-runtime)\
\
Podstawowy komponent umożliwiający efektywne uruchamianie kontenerów w Kubernetesie. Odpowiada za zarządzanie uruchamianiem i cyklem życia kontenerów w środowisku Kubernetes.\
\
Kubernetes obsługuje różne _container runtimes_: [containerd](https://containerd.io/docs/)\
, [CRI-O](https://cri-o.io/#what-is-cri-o)\
oraz każdą implementację zgodną z [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)\
.\
\
Dodatki[](https://kubernetes.io/pl/docs/concepts/_print/#addons)\
\
-----------------------------------------------------------------\
\
Dodatki (ang. Addons) wykorzystują zasoby Kubernetesa ([DaemonSet](https://kubernetes.io/pl/docs/concepts/workloads/controllers/daemonset)\
, [Deployment](https://kubernetes.io/pl/docs/concepts/workloads/controllers/deployment/)\
, itp.) do wdrażania funkcji klastra. Ponieważ zapewniają one funkcje na poziomie klastra, zasoby te należą do przestrzeni nazw `kube-system`.\
\
Wybrane dodatki są opisane poniżej; aby uzyskać rozszerzoną listę dostępnych dodatków, zobacz [Dodatki](https://kubernetes.io/docs/concepts/cluster-administration/addons/)\
.\
\
### DNS[](https://kubernetes.io/pl/docs/concepts/_print/#dns)\
\
Podczas gdy inne dodatki nie są ściśle wymagane, wszystkie klastry Kubernetes powinny mieć [DNS klastra](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)\
, ponieważ wiele elementów na nim polega.\
\
Cluster DNS to serwer DNS, będący uzupełnieniem dla innych serwerów DNS w Twoim środowisku, który obsługuje rekordy DNS dla usług Kubernetes.\
\
Kontenery uruchamiane przez Kubernetesa automatycznie uwzględniają ten serwer DNS w swoich wyszukiwaniach DNS.\
\
### Interfejs Web UI (Dashboard)[](https://kubernetes.io/pl/docs/concepts/_print/#web-ui-dashboard)\
\
[Dashboard](https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/)\
to uniwersalny interfejs internetowy dla klastrów Kubernetesa. Umożliwia użytkownikom zarządzanie i rozwiązywanie problemów z aplikacjami działającymi w klastrze, a także samym klastrem.\
\
### Monitorowanie zasobów kontenerów[](https://kubernetes.io/pl/docs/concepts/_print/#container-resource-monitoring)\
\
[Monitorowanie Zasobów Kontenera](https://kubernetes.io/docs/tasks/debug/debug-cluster/resource-usage-monitoring/)\
rejestruje ogólne metryki dotyczące kontenerów w centralnej bazie danych i udostępnia interfejs użytkownika do przeglądania tych danych.\
\
### Rejestrowanie na poziomie klastra[](https://kubernetes.io/pl/docs/concepts/_print/#cluster-level-logging)\
\
Mechanizm [logowania na poziomie klastra](https://kubernetes.io/docs/concepts/cluster-administration/logging/)\
jest odpowiedzialny za zapisywanie logów z kontenerów w centralnym magazynie logów z interfejsem do przeszukiwania/przeglądania.\
\
### Wtyczki sieciowe[](https://kubernetes.io/pl/docs/concepts/_print/#network-plugins)\
\
[Wtyczki sieciowe](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins)\
są komponentami oprogramowania, które implementują specyfikację interfejsu sieciowego kontenera (CNI). Są odpowiedzialne za przydzielanie adresów IP do podów i umożliwianie im komunikacji między sobą w klastrze.\
\
Warianty architektury[](https://kubernetes.io/pl/docs/concepts/_print/#architecture-variations)\
\
------------------------------------------------------------------------------------------------\
\
Podczas gdy podstawowe komponenty Kubernetesa pozostają niezmienne, sposób ich wdrażania i zarządzania może się różnić. Zrozumienie tych wariacji jest kluczowe dla projektowania i utrzymania klastrów Kubernetesa, które spełniają określone potrzeby operacyjne.\
\
### Opcje wdrażania warstwy sterowania[](https://kubernetes.io/pl/docs/concepts/_print/#control-plane-deployment-options)\
\
Komponenty warstwy sterowania mogą być wdrażane na kilka sposobów:\
\
Tradycyjna implementacja: : Komponenty warstwy sterowania działają bezpośrednio na dedykowanych maszynach lub maszynach wirtualnych (VM), często zarządzane jako usługi systemd.\
\
Statyczne Pody: : Komponenty warstwy sterowania są wdrażane jako statyczne Pody, zarządzane przez kubelet na określonych węzłach. Jest to powszechne podejście stosowane przez narzędzia takie jak kubeadm.\
\
Samodzielnie hostowane : Warstwa sterowania działa jako Pody wewnątrz samego klastra Kubernetes, zarządzane przez Deploymenty i StatefulSety lub inne obiekty Kubernetesa.\
\
Zarządzane usługi Kubernetesa: Dostawcy usług chmurowych zazwyczaj ukrywają warstwę kontrolną, zarządzając jej elementami w ramach swoich usług.\
\
### Rozważania dotyczące umieszczania workloadów[](https://kubernetes.io/pl/docs/concepts/_print/#workload-placement-considerations)\
\
Umiejscowienie workloadów, w tym komponentów warstwy sterowania, może różnić się w zależności od wielkości klastra, wymagań dotyczących wydajności i polityk operacyjnych:\
\
* W mniejszych klastrach lub klastrach deweloperskich, komponenty warstwy sterowania i workloady użytkowników mogą działać na tych samych węzłach.\
* Większe klastry produkcyjne często dedykują określone węzły dla komponentów warstwy sterowania, oddzielając je od workloadów użytkowników.\
* Niektóre organizacje uruchamiają krytyczne dodatki lub narzędzia monitorujące na węzłach warstwy sterowania.\
\
### Narzędzia do zarządzania klastrem[](https://kubernetes.io/pl/docs/concepts/_print/#cluster-management-tools)\
\
Narzędzia takie jak kubeadm, kops i Kubespray oferują różne podejścia do wdrażania i zarządzania klastrami, z których każde ma własną metodę rozmieszczenia i zarządzania komponentami.\
\
### Dostosowywanie i rozszerzalność[](https://kubernetes.io/pl/docs/concepts/_print/#customization-and-extensibility)\
\
Architektura Kubernetesa pozwala na szeroką konfigurację:\
\
* Niestandardowe schedulery mogą być wdrażane do pracy wraz z domyślnym schedulerem Kubernetesa lub aby całkowicie go zastąpić.\
* Serwery API mogą być rozszerzane za pomocą CustomResourceDefinitions i agregacji API.\
* Dostawcy chmury mogą mocno integrować się z Kubernetesem używając `cloud-controller-manager`.\
\
Elastyczność architektury Kubernetesa umożliwia organizacjom dostosowanie ich klastrów do specyficznych potrzeb, balansując czynniki takie jak złożoność operacyjna, wydajność i narzut na zarządzanie.\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
Dowiedz się więcej na temat:\
\
* [Węzły](https://kubernetes.io/docs/concepts/architecture/nodes/)\
i [ich komunikacja](https://kubernetes.io/docs/concepts/architecture/control-plane-node-communication/)\
z warstwą sterowania.\
* [Kontrolery Kubernetesa](https://kubernetes.io/docs/concepts/architecture/controller/)\
.\
* [kube-scheduler](https://kubernetes.io/docs/concepts/scheduling-eviction/kube-scheduler/)\
, czyli domyślny scheduler dla Kubernetesa.\
* Oficjalna [dokumentacja](https://etcd.io/docs/)\
Etcd.\
* Wiele [środowisk uruchomieniowych kontenerów](https://kubernetes.io/docs/setup/production-environment/container-runtimes/)\
w Kubernetesie.\
* Integracja z dostawcami chmury za pomocą [cloud-controller-manager](https://kubernetes.io/docs/concepts/architecture/cloud-controller/)\
.\
* Polecenia [kubectl](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands)\
.\
\
3 - Kontenery[](https://kubernetes.io/pl/docs/concepts/_print/#pg-a5f7383c83ab9eb9cd0e3c4c020b3ae6)\
\
====================================================================================================\
\
System "pakowania" aplikacji i jej zależności w spójne środowisko uruchomieniowe.\
\
Ta strona omawia kontenery i obrazy kontenerów, a także ich zastosowanie w utrzymaniu systemów i tworzeniu rozwiązań.\
\
Słowo _kontener (ang. container)_ jest wieloznacznym pojęciem. Zawsze, gdy go używasz, sprawdź, czy Twoi odbiorcy stosują tę samą definicję.\
\
Każdy uruchamiany kontener jest powtarzalny; standaryzacja wynikająca z uwzględnienia zależności oznacza, że uzyskujesz to samo zachowanie, gdziekolwiek go uruchomisz.\
\
Kontenery oddzielają aplikacje od infrastruktury hosta. To ułatwia wdrażanie w różnych środowiskach chmurowych lub systemach operacyjnych.\
\
Każdy [węzeł](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
w klastrze Kubernetesa uruchamia kontenery, które tworzą [Pody](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
przypisane do tego węzła. Kontenery należące do jednego Poda są uruchamiane razem na tym samym węźle w ramach wspólnego harmonogramu.\
\
Obrazy kontenerów[](https://kubernetes.io/pl/docs/concepts/_print/#container-images)\
\
-------------------------------------------------------------------------------------\
\
[Obraz kontenera](https://kubernetes.io/docs/concepts/containers/images/)\
to gotowy do uruchomienia pakiet oprogramowania zawierający wszystko, co jest potrzebne do uruchomienia aplikacji: kod i wszelkie wymagane środowiska uruchomieniowe, biblioteki aplikacji i systemowe, oraz wartości domyślne dla wszelkich niezbędnych ustawień.\
\
Kontenery są przeznaczone do bycia bezstanowymi i [niezmiennymi](https://glossary.cncf.io/immutable-infrastructure/)\
: nie powinieneś zmieniać kodu kontenera, który już działa. Jeśli masz aplikację konteneryzowaną i chcesz dokonać zmian, właściwym procesem jest zbudowanie nowego obrazu zawierającego zmiany, a następnie odtworzenie kontenera w celu uruchomienia go z zaktualizowanego obrazu.\
\
Środowiska uruchomieniowe kontenerów[](https://kubernetes.io/pl/docs/concepts/_print/#container-runtimes)\
\
----------------------------------------------------------------------------------------------------------\
\
Podstawowy komponent umożliwiający efektywne uruchamianie kontenerów w Kubernetesie. Odpowiada za zarządzanie uruchamianiem i cyklem życia kontenerów w środowisku Kubernetes.\
\
Kubernetes obsługuje różne _container runtimes_: [containerd](https://containerd.io/docs/)\
, [CRI-O](https://cri-o.io/#what-is-cri-o)\
oraz każdą implementację zgodną z [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md)\
.\
\
Zazwyczaj możesz pozwolić swojemu klastrowi na wybranie domyślnego środowiska uruchomieniowego kontenera dla Poda. Jeśli musisz używać więcej niż jednego środowiska uruchomieniowego kontenera w swoim klastrze, możesz określić [RuntimeClass](https://kubernetes.io/docs/concepts/containers/runtime-class/)\
dla Poda, aby upewnić się, że Kubernetes uruchamia te kontenery przy użyciu konkretnego środowiska uruchomieniowego kontenera.\
\
Możesz również użyć RuntimeClass, aby uruchamiać różne Pody z tym samym środowiskiem uruchomieniowym kontenera, ale z różnymi ustawieniami.\
\
4 - Workload[](https://kubernetes.io/pl/docs/concepts/_print/#pg-d52aadda80edd9f8c514cfe2321363c2)\
\
===================================================================================================\
\
Poznaj Pody – podstawowy element obliczeniowy w Kubernetes – oraz mechanizmy ułatwiające ich wdrażanie.\
\
Workload to ogólne określenie aplikacji działającej na Kubernetesie. Niezależnie od tego, czy Twój workload jest pojedynczym komponentem, czy kilkoma współpracującymi ze sobą, na Kubernetes uruchamiasz go wewnątrz zestawu [_podów_](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
. Pod reprezentuje zestaw uruchomionych [kontenerów](https://kubernetes.io/pl/docs/concepts/containers/)\
na Twoim klastrze.\
\
Pody mają [zdefiniowany cykl życia](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/)\
. Na przykład, gdy Pod działa w twoim klastrze, krytyczna awaria na [węźle](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
, na którym ten Pod działa, oznacza, że wszystkie Pody na tym węźle przestają działać. Kubernetes traktuje ten typ awarii jako ostateczny: przywrócenie działania wymaga utworzenia nowego Poda, nawet jeśli węzeł później zostanie przywrócony do pełnej sprawności.\
\
Jednak, aby znacznie ułatwić sobie życie, nie musisz zarządzać każdym Podem bezpośrednio. Zamiast tego, możesz użyć obiektów dedykowanych do obsługi _workload-ów_, które zarządzają zestawem Podów w Twoim imieniu. Te zasoby konfigurują [kontrolery](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
, które zapewniają, że odpowiednia liczba Podów działa, zgodnie z tym, co zdefiniowałeś.\
\
Kubernetes udostępnia kilka wbudowanych typów obiektów przeznaczonych do obsługi _workload-ów_:\
\
* [Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)\
i [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)\
(zastępując przestarzały zasób [ReplicationController](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-replication-controller)\
). Deployment jest odpowiedni do zarządzania bezstanowym workloadem aplikacji w klastrze, gdzie każdy Pod w Deployment jest wymienny i może być zastąpiony, jeśli to konieczne.\
* [StatefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)\
pozwala na uruchomienie jednego lub więcej powiązanych Podów, które przechowują stan i potrafią go odtwarzać. Na przykład, jeśli Twój workload zapisuje dane w sposób trwały, możesz uruchomić StatefulSet, który wiąże każdy Pod z [PersistentVolume](https://kubernetes.io/docs/concepts/storage/persistent-volumes/)\
. Twój kod, działający w ramach Podów dla tego StatefulSet, może replikować dane do innych Podów w tym samym StatefulSet, aby poprawić ogólną odporność na awarie.\
* [DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)\
definiuje Pody, które zapewniają funkcje lokalne dla węzłów. Za każdym razem, gdy dodajesz węzeł do swojego klastra, który pasuje do specyfikacji w DaemonSet, warstwa sterowania zleca uruchomienie Poda dla tego DaemonSet na nowym węźle. Każdy Pod w DaemonSet wykonuje zadanie podobne do demona systemowego na klasycznym serwerze Unix / POSIX. DaemonSet może być fundamentalny dla działania twojego klastra, na przykład jako wtyczka do uruchamiania [infrastuktury sieciowej klastra](https://kubernetes.io/docs/concepts/cluster-administration/networking/#how-to-implement-the-kubernetes-network-model)\
, może pomóc w zarządzaniu węzłem, lub może zapewniać opcjonalne funkcje, które ulepszają platformę kontenerową.\
* [Job](https://kubernetes.io/docs/concepts/workloads/controllers/job/)\
i [CronJob](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/)\
oferują różne sposoby definiowania zadań, które uruchamiają się do zakończenia, a następnie zatrzymują. Możesz użyć [Job](https://kubernetes.io/docs/concepts/workloads/controllers/job/)\
, aby zdefiniować zadanie, które uruchamia się do zakończenia, tylko raz. Możesz użyć [CronJob](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/)\
, aby uruchomić to samo zadanie (Job) wielokrotnie według harmonogramu.\
\
W szerszym ekosystemie Kubernetesa można znaleźć definicje zadań od firm trzecich, które zapewniają dodatkowe zachowania. Korzystając z [Custom Resource Definition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)\
, można dodać definicję zadania od firmy trzeciej, jeśli chcesz uzyskać określone działanie, które nie jest częścią podstawowej wersji Kubernetesa. Na przykład, jeśli chcesz uruchomić grupę Podów dla swojej aplikacji, ale zatrzymać pracę, jeśli _wszystkie_ Pody nie są dostępne (może dla jakiegoś zadania wysokoprzepustowego rozproszonego), to można zaimplementować lub zainstalować rozszerzenie, które oferuje tę funkcję.\
\
Rozmieszczanie workloadów[](https://kubernetes.io/pl/docs/concepts/_print/#workload-placement)\
\
-----------------------------------------------------------------------------------------------\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.35 [alpha]`(domyślnie wyłączone)\
\
Podczas gdy standardowe zasoby workloadów (takie jak Deploymenty czy Joby) zarządzają cyklem życia Podów, w niektórych przypadkach możesz mieć złożone wymagania dotyczące harmonogramowania, w których grupy Podów muszą być traktowane jako jedna całość.\
\
[Workload API](https://kubernetes.io/docs/concepts/workloads/workload-api/)\
umożliwia zdefiniowanie grupy Podów oraz zastosowanie do niej zaawansowanych polityk planowania, takich jak [gang scheduling](https://kubernetes.io/docs/concepts/scheduling-eviction/gang-scheduling/)\
. Jest to szczególnie przydatne dla workloadów związanych z przetwarzaniem wsadowym i uczeniem maszynowym, gdzie wymagane jest rozmieszczenie "wszystko albo nic".\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
Oprócz przeczytania informacji o każdym rodzaju API do zarządzania workloadami, możesz dowiedzieć się, jak wykonywać konkretne zadania:\
\
* [Uruchom aplikację bezstanową za pomocą Deployment](https://kubernetes.io/docs/tasks/run-application/run-stateless-application-deployment/)\
\
* Uruchom aplikację stanową jako [pojedynczą instancję](https://kubernetes.io/docs/tasks/run-application/run-single-instance-stateful-application/)\
lub jako [zestaw zreplikowany](https://kubernetes.io/docs/tasks/run-application/run-replicated-stateful-application/)\
\
* [Uruchamianie zadań automatycznych za pomocą CronJob](https://kubernetes.io/docs/tasks/job/automated-tasks-with-cron-jobs/)\
\
\
Aby dowiedzieć się więcej o mechanizmach Kubernetesa służących do oddzielania kodu od konfiguracji, odwiedź [Konfiguracja](https://kubernetes.io/pl/docs/concepts/configuration/)\
.\
\
Istnieją dwie wspomagające koncepcje, które dostarczają informacji o tym, jak Kubernetes zarządza Podami dla aplikacji:\
\
* [Mechanizm usuwania zbędnych obiektów (ang. Garbage collection)](https://kubernetes.io/docs/concepts/architecture/garbage-collection/)\
porządkuje obiekty z klastra po usunięciu ich _zasobu właściciela_.\
* [_Kontroler czasu życia po zakończeniu_ (time-to-live after finished)](https://kubernetes.io/docs/concepts/workloads/controllers/ttlafterfinished/)\
usuwa zadania (Jobs) po upływie określonego czasu od ich zakończenia.\
\
Gdy Twoja aplikacja jest uruchomiona, możesz chcieć udostępnić ją w internecie jako [Service](https://kubernetes.io/docs/concepts/services-networking/service/)\
lub, tylko dla aplikacji webowych, używając [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress)\
.\
\
4.1 - Pod[](https://kubernetes.io/pl/docs/concepts/_print/#pg-4d68b0ccf9c683e6368ffdcc40c838d4)\
\
================================================================================================\
\
_Pod_ jest najmniejszą jednostką obliczeniową, którą można utworzyć i zarządzać nią w Kubernetesie.\
\
_Pod_ (w języku angielskim: jak w odniesieniu do grupy wielorybów lub strąka grochu) to grupa jednego lub więcej [kontenerów](https://kubernetes.io/pl/docs/concepts/containers/)\
, z współdzielonymi zasobami pamięci i sieci, oraz specyfikacją dotyczącą sposobu uruchamiania kontenerów. Wszystkie komponenty Poda są uruchamiane razem, współdzielą ten sam kontekst i są planowane do uruchomienia na tym samym węźle. Pod modeluje specyficznego dla aplikacji "logicznego hosta": zawiera jeden lub więcej kontenerów aplikacji, które są stosunkowo ściśle ze sobą powiązane. W kontekstach niechmurowych, aplikacje wykonane na tej samej maszynie fizycznej lub wirtualnej są analogiczne do aplikacji chmurowych wykonanych na tym samym logicznym hoście.\
\
Oprócz kontenerów aplikacyjnych, Pod może zawierać [kontenery inicjalizujące](https://kubernetes.io/pl/docs/concepts/workloads/pods/init-containers/)\
uruchamiane podczas startu Pod. Możesz również wstrzyknąć [kontenery efemeryczne](https://kubernetes.io/pl/docs/concepts/workloads/pods/ephemeral-containers/)\
do debugowania działającego Poda.\
\
Czym jest Pod?[](https://kubernetes.io/pl/docs/concepts/_print/#what-is-a-pod)\
\
-------------------------------------------------------------------------------\
\
#### Informacja:\
\
Musisz zainstalować [środowisko uruchomieniowe kontenerów](https://kubernetes.io/docs/setup/production-environment/container-runtimes/)\
na każdym węźle w klastrze, aby mogły tam działać Pody.\
\
Wspólny kontekst Poda to zestaw przestrzeni nazw Linux, cgroups i potencjalnie innych aspektów izolacji - te same elementy, które izolują [kontener (ang. container)](https://kubernetes.io/pl/docs/concepts/containers/)\
. W obrębie kontekstu Poda, poszczególne aplikacje mogą mieć dodatkowo zastosowane dalsze sub-izolacje.\
\
Pod jest podobny do zestawu kontenerów z współdzielonymi przestrzeniami nazw i współdzielonymi woluminami systemu plików.\
\
Pody w klastrze Kubernetesa są używane na dwa główne sposoby:\
\
* **Pody, które uruchamiają pojedynczy kontener**. Model "jeden-kontener-na-Poda" jest najczęstszym przypadkiem użycia; w tym przypadku możesz myśleć o Podzie jako o obudowie wokół pojedynczego kontenera; Kubernetes zarządza Podami, zamiast zarządzać kontenerami bezpośrednio.\
\
* **Pody, które uruchamiają wiele kontenerów, które muszą współdziałać**. Pod może zawierać aplikację składającą się z [wielu współlokalizowanych kontenerów](https://kubernetes.io/pl/docs/concepts/_print/#how-pods-manage-multiple-containers)\
, które są ściśle powiązane i muszą współdzielić zasoby. Te współlokalizowane kontenery tworzą jedną spójną jednostkę.\
\
Grupowanie wielu współlokalizowanych i współzarządzanych kontenerów w jednym Podzie jest stosunkowo zaawansowanym przypadkiem użycia. Ten wzorzec powinieneś używać tylko w określonych przypadkach, gdy twoje kontenery są ściśle powiązane.\
\
Nie musisz uruchamiać wielu kontenerów, aby zapewnić replikację (dla odporności lub pojemności); jeśli potrzebujesz wielu replik, zobacz [zarządzanie workloadami](https://kubernetes.io/pl/docs/concepts/workloads/controllers/)\
.\
\
\
Używanie Podów[](https://kubernetes.io/pl/docs/concepts/_print/#using-pods)\
\
----------------------------------------------------------------------------\
\
Poniżej znajduje się przykład Poda, który składa się z kontenera uruchamiającego obraz `nginx:1.14.2`.\
\
[`pods/simple-pod.yaml`](https://raw.githubusercontent.com/kubernetes/website/main/content/pl/examples/pods/simple-pod.yaml)\
\
\
apiVersion: v1\
kind: Pod\
metadata:\
name: nginx\
spec:\
containers:\
- name: nginx\
image: nginx:1.14.2\
ports:\
- containerPort: 80\
\
\
Aby utworzyć Pod pokazany powyżej, uruchom następujące polecenie:\
\
kubectl apply -f https://k8s.io/examples/pods/simple-pod.yaml\
\
\
Pody zazwyczaj nie są tworzone bezpośrednio tylko przy użyciu specjalnych zadań (workload). Zobacz [Praca z Podami](https://kubernetes.io/pl/docs/concepts/_print/#working-with-pods)\
aby uzyskać więcej informacji na temat tego, jak Pody są używane z zasobami workload.\
\
### Zasoby workload do zarządzania podami[](https://kubernetes.io/pl/docs/concepts/_print/#workload-resources-for-managing-pods)\
\
Zazwyczaj nie musisz tworzyć Podów bezpośrednio, nawet pojedynczych Podów. Zamiast tego, twórz je używając zasobów workload, takich jak [Deployment](https://kubernetes.io/pl/docs/concepts/workloads/controllers/deployment/)\
lub [Job](https://kubernetes.io/pl/docs/concepts/workloads/controllers/job/)\
. Jeśli Twoje Pody muszą śledzić stan, rozważ użycie zasobu [StatefulSet](https://kubernetes.io/pl/docs/concepts/workloads/controllers/statefulset/)\
.\
\
Każdy Pod ma na celu uruchomienie pojedynczej instancji danej aplikacji. Jeśli chcesz skalować swoją aplikację horyzontalnie (aby zapewnić więcej zasobów ogółem poprzez uruchomienie większej liczby instancji), powinieneś użyć wielu Podów, jednego dla każdej instancji. W Kubernetesie, operację tę zazwyczaj określa się mianem _replikacji_. Replikowane Pody są zazwyczaj tworzone i zarządzane jako grupa przez zasób workload i jego [kontroler](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
.\
\
Zobacz [Pody i kontrolery](https://kubernetes.io/pl/docs/concepts/_print/#pods-and-controllers)\
, aby uzyskać więcej informacji na temat tego, jak Kubernetes wykorzystuje zasoby workload oraz ich kontrolery do implementacji skalowania aplikacji i automatycznego naprawiania.\
\
Pody natywnie zapewniają dwa rodzaje zasobów współdzielonych dla ich składowych kontenerów: [sieć](https://kubernetes.io/pl/docs/concepts/_print/#pod-networking)\
i [przechowywanie](https://kubernetes.io/pl/docs/concepts/_print/#pod-storage)\
.\
\
Praca z Podami[](https://kubernetes.io/pl/docs/concepts/_print/#working-with-pods)\
\
-----------------------------------------------------------------------------------\
\
Rzadko będziesz tworzyć indywidualne Pody bezpośrednio w Kubernetesie - nawet pojedyncze Pody. Dzieje się tak, ponieważ Pody są zaprojektowane jako stosunkowo efemeryczne, jednorazowe obiekty. Kiedy Pod zostaje utworzony (bezpośrednio przez Ciebie lub pośrednio przez [kontroller](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
), nowy Pod jest planowany do uruchomienia na [węźle](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
w Twoim klastrze. Pod pozostaje na tym węźle, dopóki nie zakończy wykonywania, obiekt Poda nie zostanie usunięty, Pod nie zostanie _usunięty_ z powodu braku zasobów lub węzeł ulegnie awarii.\
\
#### Informacja:\
\
Restartowanie kontenera w Podzie nie powinno być mylone z restartowaniem Poda. Pod nie jest procesem, ale środowiskiem do uruchamiania kontenera(-ów). Pod trwa, dopóki nie zostanie usunięty.\
\
Nazwa Poda musi być prawidłową wartością [poddomeny DNS](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names)\
, ale może to powodować nieoczekiwane skutki w odniesieniu do jego nazwy hosta. Dla najlepszej kompatybilności, nazwa powinna spełniać bardziej restrykcyjne zasady dla [etykiety DNS](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/names/#dns-label-names)\
.\
\
### System operacyjny Poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-os)\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.25 [stable]`\
\
Powinieneś ustawić pole `.spec.os.name` na `windows` lub `linux`, aby wskazać system operacyjny, na którym chcesz uruchomić swojego Poda. Są to jedyne obsługiwane systemy operacyjne przez Kubernetesa w chwili obecnej. W przyszłości lista ta może zostać rozszerzona.\
\
W Kubernetesie v1.35, wartość `.spec.os.name` nie wpływa na to, w jaki sposób [kube-scheduler](https://kubernetes.io/pl/docs/reference/command-line-tools-reference/kube-scheduler/)\
wybiera węzeł do uruchomienia Poda. W każdym klastrze, w którym istnieje więcej niż jeden system operacyjny dla działających węzłów, powinieneś poprawnie ustawić etykietę [kubernetes.io/os](https://kubernetes.io/docs/reference/labels-annotations-taints/#kubernetes-io-os)\
na każdym węźle i zdefiniować Pody z `nodeSelector` opartym na etykiecie systemu operacyjnego. Kube-scheduler przypisuje Pody do węzłów na podstawie określonych kryteriów, ale nie zawsze gwarantuje wybór węzła z właściwym systemem operacyjnym dla uruchamianych kontenerów. [Standardy bezpieczeństwa Pod](https://kubernetes.io/docs/concepts/security/pod-security-standards/)\
również używają tego pola, aby uniknąć wymuszania polityk, które nie mają zastosowania dla danego systemu operacyjnego.\
\
### Pody i kontrolery[](https://kubernetes.io/pl/docs/concepts/_print/#pods-and-controllers)\
\
Możesz użyć zasobów workload do tworzenia i zarządzania wieloma Podami. Kontroler dla zasobu obsługuje replikację, wdrażanie oraz automatyczne naprawianie w przypadku awarii Poda. Na przykład, jeśli węzeł ulegnie awarii, kontroler zauważa, że Pody na tym węźle przestały działać i tworzy zastępczego Poda. Scheduler umieszcza zastępczego Poda na zdrowym węźle.\
\
Oto kilka przykładów zasobów workload, które zarządzają Podami:\
\
* [Deployment](https://kubernetes.io/pl/docs/concepts/workloads/controllers/deployment/)\
\
* [StatefulSet](https://kubernetes.io/pl/docs/concepts/workloads/controllers/statefulset/)\
- komponent Kubernetesa służący do zarządzania aplikacjami stateful. StatefulSet zapewnia zachowanie kolejności i spójności danych w ramach aplikacji, co jest kluczowe dla usług wymagających takiego funkcjonowania. StatefulSet śledzi, które identyfikatory Podów są skojarzone z określonymi zasobami pamięci masowej i w jakiej kolejności powinny być tworzone oraz usuwane.\
* [DaemonSet](https://kubernetes.io/pl/docs/concepts/workloads/controllers/daemonset)\
\
\
### Określanie referencji do Workloadu[](https://kubernetes.io/pl/docs/concepts/_print/#specifying-a-workload-reference)\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.35 [alpha]`(domyślnie wyłączone)\
\
Standardowo Kubernetes uruchamia (ang. schedule) każdy Pod osobno. W przypadku niektórych silnie sprzężonych aplikacji konieczne jest jednoczesne zaplanowanie całej grupy Podów, aby mogły działać poprawnie.\
\
Możesz powiązać Poda z obiektem [Workload](https://kubernetes.io/docs/concepts/workloads/workload-api/)\
, używając specjalnej [referencji do Workloadu](https://kubernetes.io/docs/concepts/workloads/pods/workload-reference/)\
. Informuje to `kube-scheduler`, że Pod należy do określonej grupy, co umożliwia mu podejmowanie skoordynowanych decyzji dotyczących rozmieszczenia całej grupy jednocześnie.\
\
### Szablony Poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-templates)\
\
Kontrolery zasobów [workload](https://kubernetes.io/pl/docs/concepts/workloads/)\
tworzą Pody z _szablonu poda_ i zarządzają tymi Podami w Twoim imieniu.\
\
PodTemplates to specyfikacje do tworzenia Podów, które są uwzględniane w zasobach workload, takich jak [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)\
, [Jobs](https://kubernetes.io/docs/concepts/workloads/controllers/job/)\
i [DaemonSets](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)\
.\
\
Każdy kontroler dla zasobu workload używa `PodTemplate` wewnątrz obiektu workload do tworzenia rzeczywistych Podów. `PodTemplate` jest częścią pożądanego stanu dowolnego zasobu workload, którego użyłeś do uruchomienia swojej aplikacji.\
\
Gdy tworzysz Pod, możesz uwzględnić [zmienne środowiskowe](https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-container/)\
w szablonie Poda dla kontenerów, które działają w Podzie.\
\
Poniższy przykład to manifest dla prostego zadania (Job) z `szablonem (template)`, który uruchamia jeden kontener. Kontener w tym Podzie wyświetla komunikat, a następnie się zatrzymuje.\
\
apiVersion: batch/v1\
kind: Job\
metadata:\
name: hello\
spec:\
template:\
# This is the pod template\
spec:\
containers:\
- name: hello\
image: busybox:1.28\
command: ['sh', '-c', 'echo "Hello, Kubernetes!" && sleep 3600']\
restartPolicy: OnFailure\
# The pod template ends here\
\
\
Modyfikacja szablonu poda lub przejście na nowy szablon poda nie ma bezpośredniego wpływu na już istniejące Pody. Jeśli zmienisz szablon poda dla zasobu workload, ten zasób musi utworzyć nowe, zamienne Pody, które korzystają ze zaktualizowanego szablonu.\
\
Na przykład kontroler StatefulSet zapewnia, że uruchomione Pody odpowiadają bieżącemu szablonowi Poda dla każdego obiektu StatefulSet. Jeśli edytujesz StatefulSet, aby zmienić jego szablon, StatefulSet zaczyna tworzyć nowe Pody na podstawie zaktualizowanego szablonu. Ostatecznie, wszystkie stare Pody zostają zastąpione nowymi Podami, a aktualizacja jest zakończona.\
\
Każdy zasób workload implementuje własne zasady dotyczące obsługi zmian w szablonie Pod. Jeśli chcesz dowiedzieć się więcej o StatefulSet, zapoznaj się z [strategią aktualizacji](https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/#updating-statefulsets)\
w samouczku podstawy StatefulSet.\
\
Na poziomie węzłów [kubelet](https://kubernetes.io/pl/docs/reference/command-line-tools-reference/kubelet)\
nie kontroluje bezpośrednio szczegółów dotyczących szablonów Podów ani ich aktualizacji – są one zarządzane na wyższym poziomie abstrakcji. Taka separacja upraszcza działanie systemu i pozwala na rozszerzanie funkcjonalności klastra bez ingerencji w istniejący kod.\
\
Aktualizacja i wymiana Poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-update-and-replacement)\
\
---------------------------------------------------------------------------------------------------------\
\
Jak wspomniano w poprzedniej sekcji, gdy szablon Poda dla zasobu workload zostaje zmieniony, kontroler tworzy nowe Pody na podstawie zaktualizowanego szablonu zamiast aktualizować lub łatać istniejące Pody.\
\
Kubernetes nie uniemożliwia bezpośredniego zarządzania Podami. Możliwe jest aktualizowanie niektórych pól działającego Poda, na miejscu. Jednak operacje aktualizacji Poda, takie jak [`patch`](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/#patch-pod-v1-core)\
, oraz [`replace`](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/#replace-pod-v1-core)\
mają pewne ograniczenia:\
\
* Większość metadanych o Podzie jest niezmienna. Na przykład, nie można zmienić pól `namespace`, `name`, `uid` ani `creationTimestamp`.\
\
* Jeśli parametr `metadata.deletionTimestamp` jest ustawiony, nie można dodać nowego wpisu do listy `metadata.finalizers`.\
\
* Aktualizacje Podów nie mogą zmieniać pól innych niż `spec.containers[*].image`, `spec.initContainers[*].image`, `spec.activeDeadlineSeconds`, `spec.terminationGracePeriodSeconds`, `spec.tolerations` lub `spec.schedulingGates`. Dla `spec.tolerations` można jedynie dodawać nowe wpisy.\
\
* Podczas aktualizacji pola `spec.activeDeadlineSeconds` dozwolone są dwa typy aktualizacji:\
\
1. ustawienie nieprzypisanego pola na liczbę dodatnią;\
2. aktualizacja pola z liczby dodatniej do mniejszej, nieujemnej liczby.\
\
### Podzasoby Poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-subresources)\
\
Powyższe zasady aktualizacji dotyczą standardowych zmian w Podach, jednak niektóre pola Poda mogą być aktualizowane za pomocą _podzasobów_.\
\
* **Zmiana rozmiaru:** Podzasób `resize` umożliwia aktualizację zasobów kontenera (`spec.containers [*].resources`). Szczegółowe informacje znajdują się w sekcji [Zmiana rozmiaru zasobów kontenera](https://kubernetes.io/docs/tasks/configure-pod-container/resize-container-resources/)\
.\
* **Kontenery efemeryczne:** Podzasób `ephemeralContainers` umożliwia dodanie do Poda [kontenera efemerycznego](https://kubernetes.io/pl/docs/concepts/workloads/pods/ephemeral-containers/)\
. Aby uzyskać więcej szczegółów zobacz [Kontenery efemeryczne](https://kubernetes.io/docs/concepts/workloads/pods/ephemeral-containers/)\
.\
* **Status:** Podzasób `status` umożliwia aktualizację statusu poda. Zazwyczaj jest to używane tylko przez Kubelet i kontrolery systemowe.\
* **Przypisanie Poda do węzła:** Podzasób `binding` umożliwia ustawienie `spec.nodeName` poda za pomocą żądania typu `Binding`. Zazwyczaj jest to używane tylko przez [kube-scheduler](https://kubernetes.io/pl/docs/reference/command-line-tools-reference/kube-scheduler/)\
.\
\
### Generacja poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-generation)\
\
* Pole `metadata.generation` jest unikatowe. Zostanie automatycznie ustawione przez system w taki sposób, że nowe pody będą miały ustawioną wartość `metadata.generation` na 1, a każda aktualizacja pól zmiennych w specyfikacji poda zwiększy `metadata.generation` o 1.\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.35 [stable]`(domyślnie włączone)\
\
* Pole `observedGeneration` znajduje się w sekcji `status` obiektu typu Pod. Kubelet aktualizuje `status.observedGeneration`, aby odzwierciedlało ono numer generacji (`metadata.generation`) poda w chwili raportowania jego statusu. Dzięki temu możliwe jest powiązanie aktualnego stanu poda z wersją jego specyfikacji.\
\
#### Informacja:\
\
Pole `status.observedGeneration` jest zarządzane przez kubelet i zewnętrzne kontrolery **nie powinny modyfikować** tego pola.\
\
Różne pola statusu mogą być powiązane z `metadata.generation` bieżącej pętli synchronizacji lub z `metadata.generation` poprzedniej pętli synchronizacji. Kluczowa różnica polega na tym, czy zmiana w `spec` jest bezpośrednio odzwierciedlona w `status`, czy jest pośrednim wynikiem działającego procesu.\
\
#### Bezpośrednie aktualizacje statusu[](https://kubernetes.io/pl/docs/concepts/_print/#direct-status-updates)\
\
Dla pól statusu, gdzie przydzielona specyfikacja jest odzwierciedlona bezpośrednio, `observedGeneration` będzie powiązane z bieżącym `metadata.generation` (Generacja N).\
\
To zachowanie dotyczy:\
\
* **Statusu zmiany przydzielonych zasobów**: Status operacji zmiany rozmiaru zasobu.\
* **Przydzielonych zasobów**: Zasoby przydzielone do Poda po zmianie rozmiaru.\
* **Kontenerów efemerycznych**: Gdy nowy tymczasowy kontener zostaje dodany i znajduje się w stanie `Waiting`.\
\
#### Pośrednie aktualizacje statusu[](https://kubernetes.io/pl/docs/concepts/_print/#indirect-status-updates)\
\
Dla pól statusu, które są pośrednim wynikiem wykonania specyfikacji, pole `observedGeneration` będzie powiązane z wartością z `metadata.generation` z poprzedniej pętli synchronizacji (Generacja N-1).\
\
To zachowanie dotyczy:\
\
* **Obrazu Kontenera**: pole `ContainerStatus.ImageID` odzwierciedla obraz z poprzedniej generacji do momentu pobrania nowego obrazu i zaktualizowania kontenera.\
* **Rzeczywiście używanych zasobów**: Podczas trwającej zmiany rozmiaru, faktycznie wykorzystywane zasoby nadal odpowiadają żądaniu z poprzedniej generacji.\
* **Stanu kontenera**: Podczas trwającej zmiany rozmiaru z wymaganą polityką restartu, stan kontenera odzwierciedla żądanie z poprzedniej generacji.\
* **activeDeadlineSeconds** i **terminationGracePeriodSeconds** oraz **deletionTimestamp**: Zmiany w statusie poda wynikające z tych pól odnoszą się do specyfikacji z poprzedniej generacji.\
\
Udostępnianie zasobów i komunikacja[](https://kubernetes.io/pl/docs/concepts/_print/#resource-sharing-and-communication)\
\
-------------------------------------------------------------------------------------------------------------------------\
\
Pody umożliwiają udostępnianie danych i komunikację pomiędzy swoimi składowymi kontenerami.\
\
### Pamięć masowa w Podach[](https://kubernetes.io/pl/docs/concepts/_print/#pod-storage)\
\
Pod może określić zestaw współdzielonych zasobów pamięci masowej ([woluminów](https://kubernetes.io/pl/docs/concepts/storage/volumes/)\
). Wszystkie kontenery w Podzie mają dostęp do tych woluminów, co umożliwia im współdzielenie danych. Woluminy pozwalają również na utrzymanie danych w Podzie, nawet jeśli jeden z jego kontenerów wymaga ponownego uruchomienia. Zobacz sekcję [Storage](https://kubernetes.io/pl/docs/concepts/storage/)\
, aby dowiedzieć się więcej o tym, jak Kubernetes implementuje współdzieloną pamięć masową i udostępnia ją Podom.\
\
### Sieci Poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-networking)\
\
Każdy Pod ma przypisany unikalny adres IP dla każdej rodziny adresów. Każdy kontener w Podzie dzieli przestrzeń nazw sieci, w tym adres IP i porty sieciowe. Wewnątrz Poda (i **tylko** wtedy) kontenery, które należą do Poda mogą komunikować się ze sobą za pomocą `localhost`. Kiedy kontenery w Podzie komunikują się z jednostkami _poza Podem_, muszą koordynować sposób korzystania ze wspólnych zasobów sieciowych (takich jak porty). W ramach Poda, kontenery dzielą adres IP i przestrzeń portów, i mogą znaleźć się nawzajem za pośrednictwem `localhost`. Kontenery w Podzie mogą również komunikować się między sobą za pomocą standardowych komunikatów międzyprocesowych, takich jak semafory SystemV lub współdzielona pamięć POSIX. Kontenery w różnych Podach mają różne adresy IP i nie mogą komunikować się poprzez IPC na poziomie systemu operacyjnego bez specjalnej konfiguracji. Kontenery, które chcą nawiązać interakcję z kontenerem działającym w innym Podzie, mogą używać sieci IP do komunikacji.\
\
Kontenery w ramach Pod mają tę samą nazwę hosta systemowego, co skonfigurowane `name` dla Pod. Więcej na ten temat znajduje się w sekcji [sieci](https://kubernetes.io/docs/concepts/cluster-administration/networking/)\
.\
\
Ustawienia zabezpieczeń Poda[](https://kubernetes.io/pl/docs/concepts/_print/#pod-security)\
\
--------------------------------------------------------------------------------------------\
\
Aby ustawić ograniczenia bezpieczeństwa na Podach i kontenerach, używasz pola `securityContext` w specyfikacji Poda. To pole umożliwia szczegółową kontrolę nad tym, co może robić Pod lub poszczególne kontenery. Więcej informacji znajdziesz w sekcji [Zaawansowana konfiguracja Podów](https://kubernetes.io/docs/concepts/workloads/pods/advanced-pod-config/)\
.\
\
W ramach podstawowej konfiguracji bezpieczeństwa należy zapewnić zgodność ze standardem bezpieczeństwa podów _Baseline_ oraz uruchamiać kontenery jako użytkownik niebędący rootem. Możliwe jest skonfigurowanie podstawowych kontekstów bezpieczeństwa:\
\
apiVersion: v1\
kind: Pod\
metadata:\
name: security-context-demo\
spec:\
securityContext:\
runAsUser: 1000\
runAsGroup: 3000\
fsGroup: 2000\
containers:\
- name: sec-ctx-demo\
image: busybox\
command: ["sh", "-c", "sleep 1h"]\
\
\
W celu skonfigurowania zaawansowanych ustawień bezpieczeństwa, takich jak capabilities, profile seccomp czy inne szczegółowe opcje, zobacz rozdział [koncepcje bezpieczeństwa](https://kubernetes.io/pl/docs/concepts/security/)\
.\
\
* Aby dowiedzieć się o ograniczeniach bezpieczeństwa na poziomie jądra, które można użyć, zobacz [Ograniczenia bezpieczeństwa jądra Linux dla Podów i kontenerów](https://kubernetes.io/docs/concepts/security/linux-kernel-security-constraints)\
.\
* Aby dowiedzieć się więcej na temat kontekstu bezpieczeństwa Poda, zobacz [Konfigurowanie kontekstu bezpieczeństwa dla Poda lub kontenera](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/)\
.\
\
Statyczne Pody[](https://kubernetes.io/pl/docs/concepts/_print/#static-pods)\
\
-----------------------------------------------------------------------------\
\
_Statyczne Pody_ są zarządzane bezpośrednio przez demona kubelet na określonym węźle, bez nadzoru przez [serwer API](https://kubernetes.io/pl/docs/concepts/architecture/#kube-apiserver)\
. Podczas gdy większość Podów jest zarządzana przez warstwę sterowania (na przykład przez [Deployment](https://kubernetes.io/pl/docs/concepts/workloads/controllers/deployment/)\
), w przypadku statycznych Podów to kubelet bezpośrednio nadzoruje każdy statyczny Pod (i restartuje go, jeśli ulegnie awarii).\
\
Statyczne Pody są zawsze powiązane z jednym komponentem [Kubelet](https://kubernetes.io/pl/docs/reference/command-line-tools-reference/kubelet)\
na konkretnym węźle. Głównym zastosowaniem statycznych Podów jest uruchamianie samodzielnie hostowanej warstwy sterowania: innymi słowy, użycie kubeleta do nadzorowania poszczególnych [komponentów warstwy sterowania](https://kubernetes.io/pl/docs/concepts/architecture/#control-plane-components)\
.\
\
Kubelet automatycznie próbuje utworzyć [Pod lustrzany](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-mirror-pod)\
na serwerze API Kubernetesa dla każdego statycznego Poda. Oznacza to, że Pody działające na węźle są widoczne na serwerze API, ale nie mogą być z niego kontrolowane. Więcej informacji znajdziesz w przewodniku [Tworzenie statycznych Podów](https://kubernetes.io/docs/tasks/configure-pod-container/static-pod)\
.\
\
#### Informacja:\
\
`spec` statycznego Poda nie może odwoływać się do innych obiektów API (np. [ServiceAccount](https://kubernetes.io/pl/docs/tasks/configure-pod-container/configure-service-account/)\
, [ConfigMap](https://kubernetes.io/pl/docs/concepts/configuration/configmap/)\
, [Secret](https://kubernetes.io/pl/docs/concepts/configuration/secret/)\
, itp.).\
\
Pody z wieloma kontenerami[](https://kubernetes.io/pl/docs/concepts/_print/#how-pods-manage-multiple-containers)\
\
-----------------------------------------------------------------------------------------------------------------\
\
Pody są zaprojektowane do obsługi wielu współpracujących procesów (jako kontenery), które tworzą spójną jednostkę usługi. Kontenery w Podzie są automatycznie współlokowane i współharmonogramowane na tej samej fizycznej lub wirtualnej maszynie w klastrze. Kontenery mogą współdzielić zasoby i zależności, komunikować się ze sobą oraz koordynować, kiedy i jak są zakończane.\
\
Pody w klastrze Kubernetesa są używane na dwa główne sposoby:\
\
* **Pody, które uruchamiają pojedynczy kontener**. Model "jeden-kontener-na-Poda" jest najczęstszym przypadkiem użycia; w tym przypadku możesz myśleć o Podzie jako o obudowie wokół pojedynczego kontenera; Kubernetes zarządza Podami, zamiast zarządzać kontenerami bezpośrednio.\
* **Pody, które uruchamiają wiele kontenerów, które muszą współpracować**. Pod może zawierać aplikację składającą się z wielu współlokalizowanych kontenerów, które są ściśle powiązane i muszą współdzielić zasoby. Te współlokalizowane kontenery tworzą jedną spójną jednostkę usługi - na przykład, jeden kontener udostępniający dane przechowywane we współdzielonym wolumenie publicznym, podczas gdy osobny [kontener sidecar](https://kubernetes.io/pl/docs/concepts/workloads/pods/sidecar-containers/)\
odświeża lub aktualizuje te pliki. Pod łączy te kontenery, zasoby pamięci, oraz efemeryczną tożsamość sieciową razem jako jedną jednostkę.\
\
Na przykład, możesz mieć kontener, który działa jako serwer webowy dla plików we współdzielonym wolumenie oraz oddzielny [kontener pomocniczy (ang. sidecar container)](https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/)\
, który aktualizuje te pliki z zewnętrznego źródła, jak pokazano na poniższym diagramie:\
\
\
\
Niektóre Pody mają [kontenery inicjujące](https://kubernetes.io/pl/docs/concepts/workloads/pods/init-containers/)\
oraz [kontenery aplikacji](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-app-container)\
. Domyślnie, kontenery inicjujące uruchamiają się i kończą przed startem kontenerów aplikacji.\
\
Możesz również mieć [kontenery pomocnicze](https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/)\
, które świadczą usługi pomocnicze dla głównej aplikacji w Podzie.\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.33 [stable]`(domyślnie włączone)\
\
Domyślnie włączona bramka funkcji `SidecarContainers` [feature gate](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/)\
pozwala na określenie `restartPolicy: Always` dla kontenerów inicjalizacyjnych. Ustawienie polityki restartu `Always` zapewnia, że kontenery, dla których ją ustawisz, są traktowane jako _sidecar_ i są utrzymywane w działaniu przez cały czas życia Poda. Kontenery, które określisz jako kontenery sidecar, uruchamiają się przed główną aplikacją w Podzie i pozostają uruchomione do momentu, gdy Pod zostanie zamknięty.\
\
Kontenerowe sondy (ang. Container probes)[](https://kubernetes.io/pl/docs/concepts/_print/#container-probes)\
\
-------------------------------------------------------------------------------------------------------------\
\
_Sonda (ang. probe)_ to diagnostyka wykonywana okresowo przez kubelet na kontenerze. Aby przeprowadzić diagnostykę, kubelet może wywoływać różne akcje:\
\
* `ExecAction` (wykonywane za pomocą środowiska uruchomieniowego kontenera)\
* `TCPSocketAction` (sprawdzane bezpośrednio przez kubelet)\
* `HTTPGetAction` (sprawdzane bezpośrednio przez kubelet)\
\
Możesz przeczytać więcej o [sondach](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes)\
w dokumentacji dotyczącej cyklu życia Podów.\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
* Dowiedz się więcej o [cyklu życia Poda](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/)\
.\
* Przeczytaj o [PodDisruptionBudget](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/)\
i dowiedz się, jak możesz go używać do zarządzania dostępnością aplikacji podczas zakłóceń.\
* Pod jest zasobem najwyższego poziomu w REST API Kubernetesa. Definicja obiektu [Pod](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/)\
opisuje szczegółowo ten obiekt.\
* [Toolkit systemu rozproszonego: Wzorce dla kontenerów złożonych](https://kubernetes.io/blog/2015/06/the-distributed-system-toolkit-patterns/)\
wyjaśnia typowe układy dla Podów z więcej niż jednym kontenerem.\
* Przeczytaj o [ograniczeniach topologii Podów](https://kubernetes.io/docs/concepts/scheduling-eviction/topology-spread-constraints/)\
\
* Przeczytaj [Zaawansowaną Konfigurację Podów](https://kubernetes.io/docs/concepts/workloads/pods/advanced-pod-config/)\
, aby szczegółowo poznać ten temat. Ta strona obejmuje aspekty konfiguracji Podów wykraczające poza podstawy, w tym:\
* PriorityClasses\
* RuntimeClasses\
* zaawansowane metody konfigurowania _planowania uruchamiania Podów (ang. scheduling)_: czyli sposobu, w jaki Kubernetes wybiera węzeł dla Poda.\
\
Aby zrozumieć kontekst, dlaczego Kubernetes opakowuje wspólne API Poda w inne zasoby (takie jak [StatefulSets](https://kubernetes.io/pl/docs/concepts/workloads/controllers/statefulset/)\
lub [Deployments](https://kubernetes.io/pl/docs/concepts/workloads/controllers/deployment/)\
), możesz przeczytać o wcześniejszych rozwiązaniach, w tym:\
\
* [Aurora](https://aurora.apache.org/documentation/latest/reference/configuration/#job-schema)\
\
* [Borg](https://research.google/pubs/large-scale-cluster-management-at-google-with-borg/)\
\
* [Marathon](https://github.com/d2iq-archive/marathon)\
\
* [Omega](https://research.google/pubs/pub41684/)\
\
* [Tupperware](https://engineering.fb.com/data-center-engineering/tupperware/)\
.\
\
4.2 - Zarządzanie Workloadem[](https://kubernetes.io/pl/docs/concepts/_print/#pg-89637410cacae45a36ab1cc278c482eb)\
\
===================================================================================================================\
\
Kubernetes udostępnia kilka wbudowanych interfejsów API do deklaratywnego zarządzania Twoim [workloadem](https://kubernetes.io/pl/docs/concepts/workloads/)\
oraz jego komponentami.\
\
Twoje aplikacje działają jako kontenery wewnątrz [Podów](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
; jednakże zarządzanie pojedynczymi Podami wiąże się z dużym wysiłkiem. Na przykład, jeśli jeden Pod ulegnie awarii, prawdopodobnie będziesz chciał uruchomić nowy Pod, aby go zastąpić. Kubernetes może to zrobić za Ciebie.\
\
Używasz API Kubernetesa aby utworzyć [obiekt](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/#kubernetes-objects)\
zadania (workload), który reprezentuje wyższy poziom abstrakcji niż Pod, a następnie [warstwa sterowania](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-control-plane)\
Kubernetesa automatycznie zarządza obiektami Pod w Twoim imieniu, na podstawie specyfikacji zdefiniowanego przez Ciebie obiektu tego workloadu.\
\
Wbudowane interfejsy API do zarządzania workloadami to:\
\
[Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)\
(oraz pośrednio [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)\
), to najczęstszy sposób uruchamiania aplikacji w klastrze. Deployment jest odpowiedni do zarządzania aplikacją bezstanową w klastrze, gdzie każdy Pod w Deployment jest wymienny i może być zastąpiony w razie potrzeby. (Deploymenty zastępują przestarzałe [ReplicationController](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-replication-controller)\
API).\
\
[StatefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)\
pozwala na zarządzanie jednym lub wieloma Podami – wszystkie uruchamiają ten sam kod aplikacji – gdzie Pody opierają się na posiadaniu unikalnej tożsamości. Jest to inne niż w przypadku Deployment, gdzie oczekuje się, że Pody są wymienne. Najczęstszym zastosowaniem StatefulSet jest możliwość powiązania jego Podów z ich trwałą pamięcią masową. Na przykład, można uruchomić StatefulSet, który kojarzy każdy Pod z [PersistentVolume](https://kubernetes.io/docs/concepts/storage/persistent-volumes/)\
. Jeśli jeden z Podów w StatefulSet ulegnie awarii, Kubernetes tworzy zastępczy Pod, który jest połączony z tym samym PersistentVolume.\
\
[DaemonSet](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/)\
definiuje Pody, które zapewniają funkcje lokalne dla określonego [węzła](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
; na przykład sterownik, który umożliwia kontenerom na tym węźle dostęp do systemu przechowywania danych. DaemonSet jest wykorzystywany w sytuacjach, gdy sterownik lub inna usługa na poziomie węzła musi działać na konkretnym węźle. Każdy Pod w DaemonSet pełni rolę podobną do demona systemowego na klasycznym serwerze Unix / POSIX. DaemonSet może być kluczowy dla działania twojego klastra, na przykład jako wtyczka, która pozwala temu węzłowi uzyskać dostęp do [sieci klastrowej](https://kubernetes.io/docs/concepts/cluster-administration/networking/#how-to-implement-the-kubernetes-network-model)\
, może pomóc w zarządzaniu węzłem albo zapewnia mniej istotne funkcje, które wzbogacają używaną platformę kontenerową. Możesz uruchamiać DaemonSety (i ich pody) na każdym węźle w twoim klastrze, lub tylko na podzbiorze (na przykład instalując sterownik GPU tylko na węzłach, które mają zainstalowany GPU).\
\
Możesz użyć [Job](https://kubernetes.io/docs/concepts/workloads/controllers/job/)\
i/lub [CronJob](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/)\
do zdefiniowania zadań, które działają do momentu ukończenia, a następnie się zatrzymują. `Job` reprezentuje jednorazowe zadanie, podczas gdy każdy `CronJob` powtarza się zgodnie z harmonogramem.\
\
Inne tematy w tej sekcji:\
\
5 - Usługi, równoważenie obciążenia i sieci w Kubernetesie[](https://kubernetes.io/pl/docs/concepts/_print/#pg-0a0a7eca3e302a3c08f8c85e15d337fd)\
\
=================================================================================================================================================\
\
Pojęcia i zasoby związane z siecią w Kubernetesie.\
\
Model sieciowy Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#the-kubernetes-network-model)\
\
----------------------------------------------------------------------------------------------------------\
\
Model sieci Kubernetesa składa się z kilku części:\
\
* Każdy [pod](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
otrzymuje swój własny unikalny adres IP w całym klastrze.\
\
* Pod ma swoją własną, prywatną przestrzeń nazw sieci, która jest współdzielona przez wszystkie kontenery w ramach tego poda. Procesy działające w różnych kontenerach w tym samym podzie mogą komunikować się ze sobą za pośrednictwem `localhost`.\
* _Sieć podów_ (znana również jako sieć klastra) obsługuje komunikację między podami. Zapewnia, że (z zastrzeżeniem celowego segmentowania sieci):\
\
* Wszystkie pody mogą komunikować się ze wszystkimi innymi podami, niezależnie od tego, czy znajdują się na tym samym [węźle](https://kubernetes.io/docs/concepts/architecture/nodes/)\
, czy na różnych węzłach. Pody mogą komunikować się ze sobą bezpośrednio, bez użycia proxy ani translacji adresów (NAT).\
\
W systemie Windows ta reguła nie dotyczy podów z siecią hosta.\
\
* Agenci na węźle (takie jak demony systemowe czy kubelet) mogą komunikować się ze wszystkimi podami na tym węźle.\
\
* Obiekt API [Service](https://kubernetes.io/docs/concepts/services-networking/service/)\
pozwala na udostępnienie stabilnego (długoterminowego) adresu IP lub nazwy hosta dla usługi zrealizowanej przez jeden lub więcej backendowych podów, gdzie poszczególne pody składające się na usługę mogą zmieniać się w czasie.\
\
* Kubernetes automatycznie zarządza obiektami [EndpointSlice](https://kubernetes.io/docs/concepts/services-networking/endpoint-slices/)\
aby dostarczać informacje o Podach obsługujących daną usługę.\
\
* Implementacja proxy serwisu monitoruje zestaw obiektów Service i EndpointSlice, a także konfiguruje warstwę danych w celu kierowania ruchu serwisowego do jego backendów, używając API systemu operacyjnego lub dostawcy chmury do przechwytywania lub przepisania pakietów.\
\
* Obiekt API [Gateway](https://kubernetes.io/docs/concepts/services-networking/gateway/)\
(lub jego poprzednik, [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/)\
) umożliwia udostępnienie usług klientom znajdującym się poza klastrem.\
\
* Prostszy, ale mniej konfigurowalny mechanizm dostępu do klastra (Ingress) jest dostępny za pośrednictwem API usług (Service) z wykorzystaniem opcji [`type: LoadBalancer`](https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer)\
, pod warunkiem korzystania z obsługiwanego dostawcy chmury ([Cloud Provider](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-cloud-provider)\
).\
* [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies)\
to wbudowane API Kubernetesa, które pozwala na kontrolowanie ruchu pomiędzy podami, lub pomiędzy podami a światem zewnętrznym.\
\
\
W starszych systemach kontenerowych nie było automatycznej łączności pomiędzy kontenerami na różnych hostach, więc często konieczne było jawne tworzenie połączeń między kontenerami lub mapowanie portów kontenerów na porty hostów, aby były osiągalne przez kontenery na innych hostach. W Kubernetesie nie jest to potrzebne; model Kubernetesa polega na tym, że pody mogą być traktowane podobnie jak maszyny wirtualne lub fizyczne hosty z perspektyw alokacji portów, nazewnictwa, wykrywania usług, równoważenia obciążenia, konfiguracji aplikacji i migracji.\
\
Tylko kilka części tego modelu jest implementowanych przez Kubernetesa samodzielnie. Dla pozostałych części Kubernetes definiuje API, ale odpowiadającą funkcjonalność zapewniają zewnętrzne komponenty, z których niektóre są opcjonalne:\
\
* Konfiguracja przestrzeni nazw sieci poda jest obsługiwana przez oprogramowanie systemowe implementujące [Interfejs Uruchomieniowy Kontenera (ang. Container Runtime Interface)](https://kubernetes.io/docs/concepts/containers/cri/)\
.\
\
* Sama sieć podów jest zarządzana przez [implementację sieci podów](https://kubernetes.io/docs/concepts/cluster-administration/addons/#networking-and-network-policy)\
. W systemie Linux, większość środowisk uruchomieniowych kontenerów używa [Container Networking Interface (CNI)](https://kubernetes.io/pl/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/)\
do interakcji z implementacją sieci podów, dlatego te implementacje często nazywane są _wtyczkami CNI_.\
\
* Kubernetes dostarcza domyślną implementację proxy usług, nazywaną [kube-proxy](https://kubernetes.io/pl/docs/reference/command-line-tools-reference/kube-proxy/)\
, ale niektóre implementacje sieciowe poda używają zamiast tego własnego proxy usług, które jest ściślej zintegrowane z resztą implementacji.\
\
* NetworkPolicy jest zazwyczaj również implementowane przez implementację sieci poda. (Niektóre prostsze implementacje sieci poda nie implementują NetworkPolicy, lub administrator może zdecydować się na skonfigurowanie sieci poda bez wsparcia dla NetworkPolicy. W takich przypadkach API będzie nadal obecne, ale nie będzie miało żadnego efektu.)\
\
* Istnieje wiele [implementacji Gateway API](https://gateway-api.sigs.k8s.io/implementations/)\
, z których niektóre są specyficzne dla określonych środowisk chmurowych, inne bardziej skupione na środowiskach "bare metal", a jeszcze inne bardziej ogólne.\
\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
Samouczek [Łączenie aplikacji z usługami](https://kubernetes.io/docs/tutorials/services/connect-applications-service/)\
pozwala na naukę o Usługach i sieciach Kubernetesa poprzez praktyczne przykłady.\
\
Dokumentacja [Sieci Klastra](https://kubernetes.io/docs/concepts/cluster-administration/networking/)\
wyjaśnia, jak skonfigurować sieć dla twojego klastra, a także dostarcza przegląd użytych technologii.\
\
6 - Przechowywanie danych[](https://kubernetes.io/pl/docs/concepts/_print/#pg-f018f568c6723865753f150c3c59bdda)\
\
================================================================================================================\
\
Trwałe i tymczasowe mechanizmy przechowywania danych dla Podów w klastrze.\
\
7 - Konfiguracja[](https://kubernetes.io/pl/docs/concepts/_print/#pg-275bea454e1cf4c5adeca4058b5af988)\
\
=======================================================================================================\
\
Zasoby Kubernetesa wykorzystywane do konfiguracji Podów.\
\
8 - Bezpieczeństwo[](https://kubernetes.io/pl/docs/concepts/_print/#pg-712cb3c03ff14a39e5a83a6d9b71d203)\
\
=========================================================================================================\
\
Zasady ochrony aplikacji cloud-native.\
\
Ta sekcja dokumentacji Kubernetesa ma na celu pomoc w nauce bezpiecznego uruchamiania workloadów oraz zapoznanie z podstawowymi aspektami utrzymania bezpieczeństwa klastra Kubernetes.\
\
Kubernetes opiera się na architekturze cloud-native i korzysta z porad [CNCF](https://cncf.io/)\
dotyczących dobrych praktyk w zakresie bezpieczeństwa informacji cloud-native.\
\
Przeczytaj [Cloud Native Security and Kubernetes](https://kubernetes.io/docs/concepts/security/cloud-native-security/)\
, aby zrozumieć szerszy kontekst zabezpieczania klastrów i uruchamianych na nich aplikacji.\
\
Mechanizmy bezpieczeństwa Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#security-mechanisms)\
\
------------------------------------------------------------------------------------------------------------\
\
Kubernetes zawiera kilka interfejsów API i mechanizmów bezpieczeństwa, a także sposoby na definiowanie [polityk (ang. policies)](https://kubernetes.io/pl/docs/concepts/_print/#policies)\
, które mogą stanowić część tego, jak zarządzasz bezpieczeństwem informacji.\
\
### Ochrona warstwy sterowania[](https://kubernetes.io/pl/docs/concepts/_print/#control-plane-protection)\
\
Kluczowym mechanizmem bezpieczeństwa dla każdego klastra Kubernetes jest [kontrolowanie dostępu do API Kubernetesa](https://kubernetes.io/docs/concepts/security/controlling-access)\
.\
\
Kubernetes oczekuje, że skonfigurujesz i użyjesz TLS do zapewnienia [szyfrowania przesyłanych danych](https://kubernetes.io/docs/tasks/tls/managing-tls-in-a-cluster/)\
w obrębie warstwy sterowania oraz pomiędzy warstwą sterowania a jej klientami. Możesz także włączyć [szyfrowanie danych spoczynkowych](https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/)\
dla danych przechowywanych w obrębie warstwy sterowania Kubernetesa; Nie należy mylić tego z szyfrowaniem danych w stanie spoczynku dla własnych workloadów, co również może być dobrą praktyką.\
\
### Sekrety (ang. Secret)[](https://kubernetes.io/pl/docs/concepts/_print/#secrets)\
\
Obiekt API [Secret](https://kubernetes.io/docs/concepts/configuration/secret/)\
zapewnia podstawową ochronę dla wartości konfiguracyjnych, które wymagają poufności.\
\
### Ochrona workloadów[](https://kubernetes.io/pl/docs/concepts/_print/#workload-protection)\
\
Egzekwowanie [standardów bezpieczeństwa poda](https://kubernetes.io/docs/concepts/security/pod-security-standards/)\
zapewnia, że Pody i ich kontenery są odpowiednio izolowane. Możesz również użyć [RuntimeClasses](https://kubernetes.io/docs/concepts/containers/runtime-class)\
do zdefiniowania niestandardowej izolacji, jeśli tego potrzebujesz.\
\
[Polityki sieciowe](https://kubernetes.io/docs/concepts/services-networking/network-policies/)\
pozwalają kontrolować ruch sieciowy pomiędzy Podami lub pomiędzy Podami a siecią poza klastrem.\
\
Możesz wdrażać mechanizmy zabezpieczeń z szerszego ekosystemu, aby wprowadzać środki zapobiegawcze lub detekcyjne wokół Podów, ich kontenerów oraz obrazów, które w nich działają.\
\
### Kontrola przychodzących żądań[](https://kubernetes.io/pl/docs/concepts/_print/#admission-control)\
\
Kontrolery przychodzących żądań ([Admission controllers](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)\
) to wtyczki, które przechwytują żądania do API Kubernetesa i mogą weryfikować lub modyfikować te żądania w oparciu o konkretne pola w żądaniu. Przemyślane projektowanie tych kontrolerów pomaga unikać niezamierzonych zakłóceń, szczególnie gdy API Kubernetesa zmienia się wraz z aktualizacjami. Aby dowiedzieć się więcej, zobacz [Dobre Praktyki dla Admission Webhooks](https://kubernetes.io/docs/concepts/cluster-administration/admission-webhooks-good-practices/)\
.\
\
### Audytowanie[](https://kubernetes.io/pl/docs/concepts/_print/#auditing)\
\
Dziennik audytu Kubernetesa [audit logging](https://kubernetes.io/docs/tasks/debug/debug-cluster/audit/)\
dostarcza istotnego z punktu widzenia bezpieczeństwa, chronologicznego zbioru zapisów dokumentujących sekwencję działań w klastrze. Klastr audytuje aktywności generowane przez użytkowników, przez aplikacje korzystające z API Kubernetesa oraz przez samą warstwę sterowania.\
\
Zabezpieczenia dostawcy chmury[](https://kubernetes.io/pl/docs/concepts/_print/#cloud-provider-security)\
\
---------------------------------------------------------------------------------------------------------\
\
**Informacja:** Elementy na tej stronie dotyczą dostawców zewnętrznych wobec Kubernetesa. Autorzy projektu Kubernetesa nie ponoszą odpowiedzialności za produkty ani projekty stron trzecich. Aby dodać dostawcę, produkt lub projekt do tej listy, przed zgłoszeniem zmiany przeczytaj [przewodnik po treści](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)\
. [Więcej informacji.](https://kubernetes.io/pl/docs/concepts/_print/#third-party-content-disclaimer)\
\
Jeśli uruchamiasz klaster Kubernetes na własnym sprzęcie lub sprzęcie dostawcy chmury, zapoznaj się z dokumentacją dotyczącą najlepszych praktyk w zakresie bezpieczeństwa. Oto linki do dokumentacji bezpieczeństwa niektórych popularnych dostawców chmury:\
\
| | |\
| --- | --- |Zabezpieczenia dostawcy chmury\
| Dostawca IaaS | Link |\
| --- | --- |\
| Alibaba Cloud | [https://www.alibabacloud.com/trust-center](https://www.alibabacloud.com/trust-center) |\
| Amazon Web Services | [https://aws.amazon.com/security](https://aws.amazon.com/security) |\
| Google Cloud Platform | [https://cloud.google.com/security](https://cloud.google.com/security) |\
| Huawei Cloud | [https://www.huaweicloud.com/intl/en-us/securecenter/overallsafety](https://www.huaweicloud.com/intl/en-us/securecenter/overallsafety) |\
| IBM Cloud | [https://www.ibm.com/cloud/security](https://www.ibm.com/cloud/security) |\
| Microsoft Azure | [https://docs.microsoft.com/en-us/azure/security/azure-security](https://docs.microsoft.com/en-us/azure/security/azure-security) |\
| Oracle Cloud Infrastructure | [https://www.oracle.com/security](https://www.oracle.com/security) |\
| Tencent Cloud | [https://www.tencentcloud.com/solutions/data-security-and-information-protection](https://www.tencentcloud.com/solutions/data-security-and-information-protection) |\
| VMware vSphere | [https://www.vmware.com/solutions/security/hardening-guides](https://www.vmware.com/solutions/security/hardening-guides) |\
\
Polityki[](https://kubernetes.io/pl/docs/concepts/_print/#policies)\
\
--------------------------------------------------------------------\
\
Możesz definiować zasady bezpieczeństwa, używając mechanizmów natywnych dla Kubernetesa, takich jak [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies/)\
(deklaratywna kontrola nad filtrowaniem pakietów sieciowych) lub [ValidatingAdmissionPolicy](https://kubernetes.io/docs/reference/access-authn-authz/validating-admission-policy/)\
(deklaratywne ograniczenia dotyczące tego, jakie zmiany ktoś może wprowadzać za pomocą API Kubernetesa).\
\
Możesz również polegać na implementacjach polityk z szerszego ekosystemu wokół Kubernetesa. Kubernetes zapewnia mechanizmy rozszerzeń, aby umożliwić projektom ekosystemowym wdrażanie własnych kontroli polityk dotyczących przeglądu kodu źródłowego, zatwierdzania obrazów kontenerów, kontroli dostępu do API, sieci i innych.\
\
Aby uzyskać więcej informacji na temat mechanizmów polityki i Kubernetesa, przeczytaj [Polityki](https://kubernetes.io/pl/docs/concepts/policy/)\
.\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
Dowiedz się więcej na temat powiązanych zagadnień bezpieczeństwa Kubernetesa:\
\
* [Zabezpieczanie klastra](https://kubernetes.io/docs/tasks/administer-cluster/securing-a-cluster/)\
\
* [Znane podatności](https://kubernetes.io/docs/reference/issues-security/official-cve-feed/)\
w Kubernetesie (i linki do dalszych informacji)\
* [Szyfrowanie danych podczas przesyłania](https://kubernetes.io/docs/tasks/tls/managing-tls-in-a-cluster/)\
dla warstwy sterowania\
* [Szyfrowanie danych w spoczynku](https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/)\
\
* [Kontrola dostępu do API Kubernetesa](https://kubernetes.io/docs/concepts/security/controlling-access)\
\
* [Zasady sieciowe](https://kubernetes.io/docs/concepts/services-networking/network-policies/)\
dla Podów\
* [Sekrety w Kubernetesie](https://kubernetes.io/docs/concepts/configuration/secret/)\
\
* [Standardy bezpieczeństwa podów](https://kubernetes.io/docs/concepts/security/pod-security-standards/)\
\
* [Klasy środowisk uruchomieniowych](https://kubernetes.io/docs/concepts/containers/runtime-class)\
\
\
Poznaj kontekst:\
\
* [Bezpieczeństwo natywne dla chmury i Kubernetesa](https://kubernetes.io/docs/concepts/security/cloud-native-security/)\
\
\
Zdobądź certyfikat:\
\
* Certyfikacja [Certified Kubernetes Security Specialist](https://training.linuxfoundation.org/certification/certified-kubernetes-security-specialist/)\
oraz oficjalny kurs szkoleniowy.\
\
Przeczytaj więcej w tej sekcji:\
\
9 - Polityki[](https://kubernetes.io/pl/docs/concepts/_print/#pg-ac9161c6d952925b083ad9602b4e8e7f)\
\
===================================================================================================\
\
Stosuj polityki do zarządzania bezpieczeństwem i wdrażania najlepszych praktyk.\
\
Polityki Kubernetesa to ustawienia kontrolujące inne konfiguracje lub sposób działania aplikacji w trakcie ich działania. Kubernetes oferuje różne formy polityk, opisane poniżej:\
\
Stosowanie polityk za pomocą obiektów API[](https://kubernetes.io/pl/docs/concepts/_print/#apply-policies-using-api-objects)\
\
-----------------------------------------------------------------------------------------------------------------------------\
\
Niektóre obiekty API spełniają rolę polityk. Oto kilka przykładów:\
\
* [NetworkPolicies](https://kubernetes.io/docs/concepts/services-networking/network-policies/)\
mogą być używane do ograniczania ruchu przychodzącego i wychodzącego dla workload.\
* [LimitRanges](https://kubernetes.io/docs/concepts/policy/limit-range/)\
zarządzają ograniczeniami alokacji zasobów w różnych typach obiektów.\
* [ResourceQuotas](https://kubernetes.io/docs/concepts/policy/resource-quotas/)\
ogranicza zużycie zasobów dla [namespace](https://kubernetes.io/pl/docs/concepts/overview/working-with-objects/namespaces)\
.\
\
Stosowanie polityk za pomocą kontrolerów dopuszczania (ang. Admission Controllers)[](https://kubernetes.io/pl/docs/concepts/_print/#apply-policies-using-admission-controllers)\
\
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\
\
Kontroler dopuszczania (ang. Admission Controller - [admission controller](https://kubernetes.io/pl/docs/reference/access-authn-authz/admission-controllers/)\
) działa na serwerze API i może weryfikować lub modyfikować żądania API. Niektóre takie kontrolery działają w celu zastosowania polityk. Na przykład kontroler [AlwaysPullImages](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#alwayspullimages)\
modyfikuje nowy Pod, aby ustawić politykę pobierania obrazów na `Always`.\
\
Kubernetes ma kilka wbudowanych kontrolerów dostępu, które można konfigurować za pomocą flagi `--enable-admission-plugins` serwera API.\
\
Szczegóły dotyczące kontrolerów dopuszczania są udokumentowane w dedykowanej sekcji:\
\
* [Kontrolery dopuszczania (ang. Admission Controllers)](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)\
\
\
Stosowanie polityk używając ValidatingAdmissionPolicy[](https://kubernetes.io/pl/docs/concepts/_print/#apply-policies-using-validatingadmissionpolicy)\
\
-------------------------------------------------------------------------------------------------------------------------------------------------------\
\
Polityki walidacji przyjmowania (ang. Validating admission policies) umożliwiają wykonywanie konfigurowalnych kontroli walidacji na serwerze API przy użyciu wspólnego języka wyrażeń (CEL). Na przykład, `ValidatingAdmissionPolicy` może być używana do zakazania użycia tagu obrazu `latest`.\
\
Polityka `ValidatingAdmissionPolicy` działa na żądaniach API i może być używana do blokowania, audytowania oraz ostrzegania użytkowników o niezgodnych konfiguracjach.\
\
Szczegóły dotyczące API `ValidatingAdmissionPolicy`, wraz z przykładami, są udokumentowane w dedykowanej sekcji:\
\
* [Walidacja Polityki Dopuszczania (ang. Validating Admission Policy)](https://kubernetes.io/docs/reference/access-authn-authz/validating-admission-policy/)\
\
\
Stosowanie polityk przy użyciu dynamicznej kontroli dostępu[](https://kubernetes.io/pl/docs/concepts/_print/#apply-policies-using-dynamic-admission-control)\
\
-------------------------------------------------------------------------------------------------------------------------------------------------------------\
\
Dynamiczne kontrolery dostępu (lub webhooki dostępu) działają poza serwerem API jako oddzielne aplikacje, które rejestrują się do odbierania żądań webhooków w celu przeprowadzania weryfikacji lub modyfikacji żądań API.\
\
Dynamiczne kontrolery dopuszczeń mogą być używane do stosowania polityk na żądaniach API i uruchamiania innych procesów opartych na politykach. Dynamiczny kontroler dopuszczeń może przeprowadzać skomplikowane kontrole, w tym te, które wymagają pobierania innych zasobów klastra i danych zewnętrznych. Na przykład, kontrola weryfikacji obrazu może wyszukiwać dane z rejestrów OCI, aby zatwierdzić podpisy i atestacje obrazów kontenerów.\
\
Szczegóły dotyczące dynamicznej kontroli dostępu są udokumentowane w dedykowanej sekcji:\
\
* [Dynamiczne Sterowanie Dostępem](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/)\
\
\
### Implementacje[](https://kubernetes.io/pl/docs/concepts/_print/#implementations-admission-control)\
\
**Informacja:** Ta sekcja przekierowuje do projektów zewnętrznych (niżej ich lista alfabetyczna), które udostępniają funkcjonalności wymagane przez Kubernetesa. Autorzy Kubernetesa nie odpowiadają za te projekty. Jeśli chcesz dodać projekt do tego wykazu, zanim wprowadzisz zmiany, przeczytaj [nasz przewodnik](https://kubernetes.io/docs/contribute/style/content-guide/#third-party-content)\
.\
\
Dynamiczne kontrolery dopuszczeń (Admission Controllers), które działają jako elastyczne silniki polityki, są rozwijane w ekosystemie Kubernetesa:\
\
* [Kubewarden](https://github.com/kubewarden)\
\
* [Kyverno](https://kyverno.io/)\
\
* [OPA Gatekeeper](https://github.com/open-policy-agent/gatekeeper)\
\
* [Polaris](https://polaris.docs.fairwinds.com/admission-controller/)\
\
\
Stosowanie zasad za pomocą konfiguracji Kubelet[](https://kubernetes.io/pl/docs/concepts/_print/#apply-policies-using-kubelet-configurations)\
\
----------------------------------------------------------------------------------------------------------------------------------------------\
\
Kubernetes pozwala na konfigurowanie Kubelet na każdym węźle roboczym. Niektóre konfiguracje Kubelet działają jako polityki:\
\
* [Limity i rezerwacje identyfikatorów procesów](https://kubernetes.io/docs/concepts/policy/pid-limiting/)\
są używane do ograniczania i rezerwacji dostępnych PID-ów.\
* [Menedżery zasobów węzła](https://kubernetes.io/docs/concepts/policy/node-resource-managers/)\
mogą zarządzać zasobami obliczeniowymi, pamięci oraz urządzeniami dla workloadów krytycznych pod względem opóźnień i o wysokiej przepustowości.\
\
10 - Harmonogramowanie, pierszeństwo i eksmisja[](https://kubernetes.io/pl/docs/concepts/_print/#pg-c21d05f31057c5bcd2ebdd01f4e62a0e)\
\
======================================================================================================================================\
\
W Kubernetesie, planowanie odnosi się do zapewnienia, że [Pody](https://kubernetes.io/pl/docs/concepts/workloads/pods/)\
są dopasowane do [Węzłów](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
, aby [kubelet](https://kubernetes.io/pl/docs/reference/command-line-tools-reference/kubelet)\
mógł je uruchomić. Pierszeństwo (ang. preemption) to proces zakończania Podów z niższym [Priorytetem](https://kubernetes.io/pl/docs/concepts/scheduling-eviction/pod-priority-preemption/#pod-priority)\
po to, aby Pody z wyższym Priorytetem mogły być zaplanowane na Węzłach. Eksmisja (ang. eviction) to proces zakończania jednego lub więcej Podów na Węzłach.\
\
Harmonogramowanie[](https://kubernetes.io/pl/docs/concepts/_print/#scheduling)\
\
-------------------------------------------------------------------------------\
\
* [Scheduler Kubernetesa](https://kubernetes.io/docs/concepts/scheduling-eviction/kube-scheduler/)\
\
* [Przypisywanie Podów do Węzłów](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/)\
\
* [Narzut na utrzymanie poda (ang. Pod overhead)](https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/)\
\
* [Reguły rozmieszczenia Podów w klastrze](https://kubernetes.io/docs/concepts/scheduling-eviction/topology-spread-constraints/)\
\
* [Reguły wykluczania i dopuszczania podów](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/)\
\
* [Scheduling Framework](https://kubernetes.io/docs/concepts/scheduling-eviction/scheduling-framework)\
\
* [Dynamiczne przydzielanie zasobów](https://kubernetes.io/docs/concepts/scheduling-eviction/dynamic-resource-allocation)\
\
* [Tuning wydajności schedulera](https://kubernetes.io/docs/concepts/scheduling-eviction/scheduler-perf-tuning/)\
\
* [Pakowanie zasobów (Bin Packing) dla niestandardowych zasobów klastra](https://kubernetes.io/docs/concepts/scheduling-eviction/resource-bin-packing/)\
\
* [Gotowość do planowania Podów](https://kubernetes.io/docs/concepts/scheduling-eviction/pod-scheduling-readiness/)\
\
* [Planowanie grupowe (ang. Gang Scheduling)](https://kubernetes.io/docs/concepts/scheduling-eviction/gang-scheduling/)\
\
* [Descheduler](https://github.com/kubernetes-sigs/descheduler#descheduler-for-kubernetes)\
\
* [Deklarowane funkcje węzłów](https://kubernetes.io/docs/concepts/scheduling-eviction/node-declared-features/)\
\
\
Zakłócenia w działaniu Podów[](https://kubernetes.io/pl/docs/concepts/_print/#pod-disruption)\
\
----------------------------------------------------------------------------------------------\
\
[Zakłócenie działania Poda](https://kubernetes.io/docs/concepts/workloads/pods/disruptions/)\
to proces, w ramach którego Pody na węzłach są zakończone dobrowolnie lub mimowolnie.\
\
Dobrowolne zakłócenia są inicjowane celowo przez właścicieli aplikacji lub administratorów klastra. Mimowolne zakłócenia są niezamierzone i mogą być spowodowane nieuniknionymi problemami, takimi jak wyczerpanie [zasobów](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-infrastructure-resource)\
na węzłach, lub przypadkowymi usunięciami.\
\
* [Priorytet poda i wywłaszczenie](https://kubernetes.io/docs/concepts/scheduling-eviction/pod-priority-preemption/)\
\
* [Usuwanie z powodu presji na węzeł](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/)\
\
* [Usunięcie zainicjowane przez API](https://kubernetes.io/docs/concepts/scheduling-eviction/api-eviction/)\
\
\
11 - Administracja klastrem[](https://kubernetes.io/pl/docs/concepts/_print/#pg-285a3785fd3d20f437c28d87ca4dadca)\
\
==================================================================================================================\
\
Niskopoziomowe szczegóły istotne dla tworzenia i administracji klastrem Kubernetesa.\
\
Rozdział dotyczący administracji klastrem jest przeznaczony dla każdego, kto tworzy lub zarządza klastrem Kubernetesa. Zakłada się pewną znajomość podstawowych [pojęć](https://kubernetes.io/pl/docs/concepts/)\
Kubernetesa.\
\
Planowanie klastra[](https://kubernetes.io/pl/docs/concepts/_print/#planning-a-cluster)\
\
----------------------------------------------------------------------------------------\
\
Zobacz przewodniki w [Od czego zacząć](https://kubernetes.io/pl/docs/setup/)\
zawierające przykłady planowania, konfiguracji i uruchamiania klastrów Kubernetes. Rozwiązania wymienione w tym artykule nazywane są _dystrybucjami_.\
\
#### Informacja:\
\
Nie wszystkie dystrybucje są aktywnie utrzymywane. Wybierz dystrybucje, które zostały przetestowane z aktualną wersją Kubernetesa.\
\
Rozważ:\
\
* Czy chcesz wypróbować Kubernetesa na swoim komputerze, czy może chcesz zbudować klaster o wysokiej dostępności, złożony z wielu węzłów? Wybierz dystrybucję najlepiej dostosowaną do Twoich potrzeb.\
* Czy będziesz korzystać z **hostowanego klastra Kubernetesa**, takiego jak [Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine/)\
, czy też **hostować własny klaster**?\
* Czy Twój klaster będzie **w lokalnym centrum obliczeniowym (on-premises)**, czy **w chmurze (IaaS)**? Kubernetes nie obsługuje bezpośrednio klastrów hybrydowych. Zamiast tego, możesz skonfigurować wiele klastrów.\
* **Jeśli konfigurujesz Kubernetesa lokalnie**, zastanów się, który [model sieciowy](https://kubernetes.io/docs/concepts/cluster-administration/networking/)\
pasuje najlepiej.\
* Czy będziesz uruchamiać Kubernetesa na sprzęcie typu **"bare metal"** czy na **maszynach wirtualnych (VM)**?\
* Czy **chcesz uruchomić klaster**, czy raczej zamierzasz prowadzić **aktywny rozwój kodu projektu Kubernetes**? Jeśli to drugie, wybierz dystrybucję aktywnie rozwijaną. Niektóre dystrybucje używają tylko wydań binarnych, ale oferują większą różnorodność wyboru.\
* Zapoznaj się z [komponentami](https://kubernetes.io/pl/docs/concepts/overview/components/)\
potrzebnymi do uruchomienia klastra.\
\
Zarządzanie klastrem[](https://kubernetes.io/pl/docs/concepts/_print/#managing-a-cluster)\
\
------------------------------------------------------------------------------------------\
\
* Dowiedz się, jak [zarządzać węzłami](https://kubernetes.io/docs/concepts/architecture/nodes/)\
.\
\
* Przeczytaj o [automatycznym skalowaniu węzłów](https://kubernetes.io/docs/concepts/cluster-administration/node-autoscaling/)\
.\
* Dowiedz się, jak skonfigurować i zarządzać [przydziałem zasobów](https://kubernetes.io/docs/concepts/policy/resource-quotas/)\
dla współdzielonych klastrów.\
\
\
Zabezpieczanie klastra[](https://kubernetes.io/pl/docs/concepts/_print/#securing-a-cluster)\
\
--------------------------------------------------------------------------------------------\
\
* [Generowanie Certyfikatów](https://kubernetes.io/docs/tasks/administer-cluster/certificates/)\
opisuje kroki generowania certyfikatów z użyciem różnych zestawów narzędzi.\
\
* [Środowisko Kontenerów Kubernetesa](https://kubernetes.io/docs/concepts/containers/container-environment/)\
opisuje środowisko dla zarządzanych przez Kubelet kontenerów na węźle Kubernetesa.\
\
* [Kontrola dostępu do API Kubernetesa](https://kubernetes.io/docs/concepts/security/controlling-access)\
opisuje, jak Kubernetes implementuje kontrolę dostępu do swojego API.\
\
* [Uwierzytelnianie](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)\
wyjaśnia uwierzytelnianie w Kubernetesie, w tym różne opcje uwierzytelniania.\
\
* [Autoryzacja](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)\
jest oddzielona od uwierzytelniania i kontroluje, w jaki sposób obsługiwane są wywołania HTTP.\
\
* [Korzystanie z kontrolerów dopuszczania (Admission Controllers)](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)\
opisuje wtyczki, które przechwytują żądania do serwera API Kubernetesa po uwierzytelnieniu i autoryzacji.\
\
* Dokument [Dobre Praktyki dla Admission Webhooks](https://kubernetes.io/docs/concepts/cluster-administration/admission-webhooks-good-practices/)\
opisuje zalecane podejście i ważne aspekty, które należy uwzględnić przy tworzeniu webhooków modyfikujących oraz wehbooków walidujących w Kubernetesie.\
\
* [Używanie Sysctls w klastrach Kubernetesa](https://kubernetes.io/docs/tasks/administer-cluster/sysctl-cluster/)\
opisuje administratorowi, jak używać narzędzia wiersza polecenia `sysctl` do ustawiania parametrów jądra.\
\
* [Audyt](https://kubernetes.io/docs/tasks/debug/debug-cluster/audit/)\
opisuje, jak współpracować z logami audytowymi Kubernetesa.\
\
\
### Zabezpieczanie kubeleta[](https://kubernetes.io/pl/docs/concepts/_print/#securing-the-kubelet)\
\
* [Komunikacja warstwy sterowania z węzłem](https://kubernetes.io/docs/concepts/architecture/control-plane-node-communication/)\
\
* [TLS bootstrapping](https://kubernetes.io/docs/reference/access-authn-authz/kubelet-tls-bootstrapping/)\
\
* [Uwierzytelnianie/autoryzacja Kubelet](https://kubernetes.io/docs/reference/access-authn-authz/kubelet-authn-authz/)\
\
\
Opcjonalne usługi klastra[](https://kubernetes.io/pl/docs/concepts/_print/#optional-cluster-services)\
\
------------------------------------------------------------------------------------------------------\
\
* [Integracja DNS](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)\
opisuje, jak rozwiązać nazwę DNS bezpośrednio do usługi Kubernetesa.\
\
* [Logowanie i monitorowanie aktywności klastra](https://kubernetes.io/docs/concepts/cluster-administration/logging/)\
wyjaśnia, jak działa logowanie w Kubernetesie i jak je zaimplementować.\
\
\
12 - Windows w Kubernetesie[](https://kubernetes.io/pl/docs/concepts/_print/#pg-05a1231ecbfe48ec554e6d078818aca4)\
\
==================================================================================================================\
\
Kubernetes obsługuje węzły działające na systemie Microsoft Windows.\
\
Kubernetes obsługuje [węzły](https://kubernetes.io/pl/docs/concepts/architecture/nodes/)\
robocze działające zarówno na systemie Linux, jak i Microsoft Windows.\
\
🛇 Ta pozycja przekierowuje do projektu lub produktu, który nie jest częścią projektu Kubernetes. [Więcej informacji](https://kubernetes.io/pl/docs/concepts/_print/#third-party-content-disclaimer)\
\
CNCF i jej macierzysta organizacja Linux Foundation przyjmują neutralne podejście do kompatybilności w kontekście dostawców. Możliwe jest dołączenie swojego [serwera Windows](https://www.microsoft.com/en-us/windows-server)\
jako węzeł roboczy do klastra Kubernetes.\
\
Możesz [zainstalować i skonfigurować kubectl na Windows](https://kubernetes.io/docs/tasks/tools/install-kubectl-windows/)\
niezależnie od tego, jakiego systemu operacyjnego używasz w ramach swojego klastra.\
\
Jeśli używasz węzłów Windows, możesz przeczytać:\
\
* [Sieci w Windows](https://kubernetes.io/docs/concepts/services-networking/windows-networking/)\
\
* [Windows storage w Kubernetesie](https://kubernetes.io/docs/concepts/storage/windows-storage/)\
\
* [Zarządzanie zasobami dla węzłów Windows](https://kubernetes.io/docs/concepts/configuration/windows-resource-management/)\
\
* [Konfiguracja RunAsUserName dla Podów Windows i kontenerów](https://kubernetes.io/docs/tasks/configure-pod-container/configure-runasusername/)\
\
* [Utwórz Windows HostProcess Pod](https://kubernetes.io/docs/tasks/configure-pod-container/create-hostprocess-pod/)\
\
* [Konfigurowanie grupowych zarządzanych kont Usług dla Podów i kontenerów Windows](https://kubernetes.io/docs/tasks/configure-pod-container/configure-gmsa/)\
\
* [Bezpieczeństwo dla węzłów Windows](https://kubernetes.io/docs/concepts/security/windows-security/)\
\
* [Wskazówki dotyczące debugowania w systemie Windows](https://kubernetes.io/docs/tasks/debug/debug-cluster/windows/)\
\
* [Przewodnik dotyczący harmonogramowania kontenerów Windows w Kubernetesie](https://kubernetes.io/docs/concepts/windows/user-guide)\
\
\
lub, aby uzyskać przegląd, przeczytaj:\
\
13 - Rozszerzanie Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#pg-7e0d97616b15e2c383c6a0a96ec442cb)\
\
====================================================================================================================\
\
Różne sposoby na modyfikację działania klastra Kubernetesa.\
\
Kubernetes jest wysoce konfigurowalny i rozbudowywalny. W rezultacie rzadko istnieje potrzeba robienia forka lub przesyłania poprawek do kodu projektu.\
\
Ten przewodnik opisuje opcje dostosowywania klastra Kubernetesa. Jest skierowany do [operatorów klastrów](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-cluster-operator)\
, którzy chcą zrozumieć, jak dostosować swój klaster Kubernetesa do potrzeb środowiska pracy. Programiści, którzy są potencjalnymi [Deweloperami Platformy](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-platform-developer)\
lub [Współtwórcami](https://kubernetes.io/pl/docs/reference/glossary/?all=true#term-contributor)\
projektu Kubernetes również uznają go za przydatny jako wprowadzenie do istniejących punktów rozszerzeń i wzorców oraz ich kompromisów i ograniczeń.\
\
Podejścia do dostosowywania można ogólnie podzielić na [konfigurację](https://kubernetes.io/pl/docs/concepts/_print/#configuration)\
, która obejmuje tylko zmiany argumentów wiersza poleceń, lokalnych plików konfiguracyjnych lub zasobów API; oraz [rozszerzenia](https://kubernetes.io/pl/docs/concepts/_print/#extensions)\
, które obejmują uruchamianie dodatkowych programów, dodatkowych usług sieciowych lub obu. Ten dokument dotyczy przede wszystkim _rozszerzeń_.\
\
Konfiguracja[](https://kubernetes.io/pl/docs/concepts/_print/#configuration)\
\
-----------------------------------------------------------------------------\
\
_Pliki konfiguracyjne_ i _argumenty poleceń_ są udokumentowane w sekcji [Materiały źródłowe (ang. Reference)](https://kubernetes.io/pl/docs/reference/)\
dokumentacji online, z osobną stroną dla każdego pliku binarnego:\
\
* [`kube-apiserver`](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-apiserver/)\
\
* [`kube-controller-manager`](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-controller-manager/)\
\
* [`kube-scheduler`](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-scheduler/)\
\
* [`kubelet`](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/)\
\
* [`kube-proxy`](https://kubernetes.io/docs/reference/command-line-tools-reference/kube-proxy/)\
\
\
Argumenty poleceń i pliki konfiguracyjne mogą nie zawsze być możliwe do zmiany w hostowanej usłudze Kubernetesa lub w dystrybucji z zarządzaną instalacją. Kiedy są możliwe do zmiany, zazwyczaj mogą być zmieniane tylko przez operatora klastra. Dodatkowo, mogą ulegać zmianom w przyszłych wersjach Kubernetesa, a ich ustawienie może wymagać ponownego uruchomienia procesów. Z tych powodów należy je używać tylko wtedy, gdy nie ma innych opcji.\
\
Wbudowane _interfejsy API polityk_, takie jak [ResourceQuota](https://kubernetes.io/docs/concepts/policy/resource-quotas/)\
, [NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies/)\
i Role-based Access Control ( [RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/)\
), to natywne API Kubernetesa umożliwiające deklaratywną konfigurację polityk. Interfejsy API są zazwyczaj użyteczne nawet w przypadku hostowanych usług Kubernetesa i zarządzanych instalacji Kubernetesa. Wbudowane interfejsy API polityk przestrzegają tych samych konwencji co inne zasoby Kubernetesa, takie jak Pody. Gdy korzystasz z API polityk, które są [stabilne](https://kubernetes.io/docs/reference/using-api/#api-versioning)\
, masz zapewnione [określone wsparcie](https://kubernetes.io/docs/reference/using-api/deprecation-policy/)\
, zgodnie z ogólną polityką wsparcia API Kubernetesa. Z tych powodów interfejsy API polityk są zalecane zamiast _plików konfiguracyjnych_ i _argumentów poleceń_, tam gdzie to możliwe.\
\
Rozszerzenia[](https://kubernetes.io/pl/docs/concepts/_print/#extensions)\
\
--------------------------------------------------------------------------\
\
Rozszerzenia to komponenty oprogramowania, które rozszerzają i głęboko integrują się z Kubernetesem. Dostosowują go do obsługi nowych typów i nowych rodzajów sprzętu.\
\
Wielu administratorów klastra korzysta z hostowanej lub dystrybucyjnej instancji Kubernetesa. Te klastry mają zainstalowane rozszerzenia. W rezultacie, większość użytkowników Kubernetesa nie będzie musiała instalować rozszerzeń, a jeszcze mniej użytkowników będzie musiało tworzyć nowe.\
\
### Wzorce rozszerzeń[](https://kubernetes.io/pl/docs/concepts/_print/#extension-patterns)\
\
Kubernetes jest zaprojektowany tak, aby można go było zautomatyzować poprzez pisanie programów klienckich. Każdy program, który odczytuje i/lub zapisuje do API Kubernetesa, może zapewnić użyteczną automatyzację. _Automatyzacja_ może działać zarówno na klastrze, jak i poza nim. Postępując zgodnie z wytycznymi zawartymi w tym dokumencie, możesz napisać wysoce dostępną i solidną automatyzację. Automatyzacja generalnie działa z dowolnym klastrem Kubernetesa, w tym klastrami hostowanymi i zarządzanymi instalacjami.\
\
Istnieje specyficzny wzorzec pisania programów klienckich, które dobrze współpracują z Kubernetesem, zwany wzorcem [kontrolera](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
. Kontrolery zazwyczaj odczytują `.spec` obiektu, ewentualnie wykonują pewne czynności, a następnie aktualizują `.status` obiektu.\
\
Kontroler jest klientem API Kubernetesa. Gdy Kubernetes działa jako klient i wywołuje zdalną usługę, nazywa to _webhookiem_. Zdalna usługa nazywana jest _backendem webhooka_. Podobnie jak w przypadku niestandardowych kontrolerów, webhooki stanowią dodatkowy potencjalny punkt awarii.\
\
#### Informacja:\
\
Poza Kubernetesen, termin "webhook" zazwyczaj odnosi się do mechanizmu asynchronicznych powiadomień, gdzie wywołanie webhooka służy jako jednostronne powiadomienie do innego systemu lub komponentu. W ekosystemie Kubernetesa, nawet synchroniczne wywołania HTTP są często opisywane jako "webhooki".\
\
W modelu webhook Kubernetes wykonuje żądanie sieciowe do zdalnej usługi. W alternatywnym modelu _binarnej wtyczki_, Kubernetes wykonuje program binarny. Wtyczki binarne są używane przez kubelet (na przykład, [wtyczki magazynu CSI](https://kubernetes-csi.github.io/docs/)\
i [wtyczki sieciowe CNI](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/)\
), oraz przez kubectl (zobacz [Rozszerz kubectl za pomocą wtyczek](https://kubernetes.io/docs/tasks/extend-kubectl/kubectl-plugins/)\
).\
\
### Punkty rozszerzeń[](https://kubernetes.io/pl/docs/concepts/_print/#extension-points)\
\
Ten diagram pokazuje punkty rozszerzeń w klastrze Kubernetesa oraz klientów, którzy uzyskują do niego dostęp.\
\
\
\
Punkty rozszerzeń Kubernetesa\
\
#### Klucz do rysunku[](https://kubernetes.io/pl/docs/concepts/_print/#key-to-the-figure)\
\
1. Użytkownicy często wchodzą w interakcję z API Kubernetesa za pomocą `kubectl`. [Wtyczki](https://kubernetes.io/pl/docs/concepts/_print/#client-extensions)\
dostosowują zachowanie klientów. Istnieją ogólne rozszerzenia, które mogą być stosowane do różnych klientów, a także specyficzne sposoby rozszerzania `kubectl`.\
\
2. Serwer API obsługuje wszystkie żądania. Kilka typów punktów rozszerzeń w serwerze API umożliwia uwierzytelnianie żądań, blokowanie ich na podstawie ich treści, edytowanie treści oraz obsługę usuwania. Są one opisane w sekcji [Rozszerzenia dostępu do API](https://kubernetes.io/pl/docs/concepts/_print/#api-access-extensions)\
.\
\
3. Serwer API obsługuje różne rodzaje _zasobów_. _Wbudowane rodzaje zasobów_, takie jak `pods`, są definiowane przez projekt Kubernetesa i nie mogą być modyfikowane. Przeczytaj [Rozszerzenia API](https://kubernetes.io/pl/docs/concepts/_print/#api-extensions)\
, aby dowiedzieć się więcej o rozszerzaniu API Kubernetesa.\
\
4. Scheduler Kubernetesa [decyduje](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/)\
, na których węzłach umieścić pody. Istnieje kilka sposobów na rozszerzenie harmonogramowania, które są opisane w sekcji [Rozszerzenia harmonogramowania](https://kubernetes.io/pl/docs/concepts/_print/#scheduling-extensions)\
.\
\
5. Duża część zachowań Kubernetesa jest realizowana przez programy zwane [kontrolerami](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
, które są klientami serwera API. Kontrolery są często używane w połączeniu z niestandardowymi zasobami. Przeczytaj [łączenie nowych API z automatyzacją](https://kubernetes.io/pl/docs/concepts/_print/#combining-new-apis-with-automation)\
oraz [Zmiana wbudowanych zasobów](https://kubernetes.io/pl/docs/concepts/_print/#changing-built-in-resources)\
, aby dowiedzieć się więcej.\
\
6. Kubelet działa na serwerach (węzłach) i pomaga podom wyglądać jak wirtualne serwery z własnymi adresami IP w sieci klastra. [Wtyczki sieciowe](https://kubernetes.io/pl/docs/concepts/_print/#network-plugins)\
umożliwiają różne implementacje sieciowania podów.\
\
7. Możesz użyć [Pluginów Urządzeń](https://kubernetes.io/pl/docs/concepts/_print/#device-plugins)\
, aby zintegrować niestandardowy sprzęt lub inne specjalne lokalne dla węzła funkcje i udostępnić je Podom działającym w Twoim klastrze. Kubelet zawiera wsparcie dla pracy z pluginami urządzeń.\
\
Kubelet również montuje i odmontowuje [volume](https://kubernetes.io/pl/docs/concepts/storage/volumes/)\
dla podów i ich kontenerów. Możesz użyć [wtyczek magazynowania](https://kubernetes.io/pl/docs/concepts/_print/#storage-plugins)\
, aby dodać obsługę nowych rodzajów magazynu (ang. storage) i innych typów wolumenów.\
\
\
#### Schemat przepływu wyboru punktu rozszerzenia[](https://kubernetes.io/pl/docs/concepts/_print/#extension-flowchart)\
\
Jeśli nie jesteś pewien, od czego zacząć, ten schemat blokowy może pomóc. Zwróć uwagę, że niektóre rozwiązania mogą obejmować kilka typów rozszerzeń.\
\
\
\
Przewodnik do wyboru metody rozszerzenia\
\
* * *\
\
Rozszerzenia klienta[](https://kubernetes.io/pl/docs/concepts/_print/#client-extensions)\
\
-----------------------------------------------------------------------------------------\
\
Wtyczki do `kubectl` to oddzielne pliki binarne, które dodają lub zastępują działanie określonych poleceń. Narzędzie `kubectl` może również integrować się z [wtyczkami uwierzytelniania](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#client-go-credential-plugins)\
. Te rozszerzenia wpływają tylko na lokalne środowisko danego użytkownika, dlatego nie mogą wymuszać polityk dla całego serwisu.\
\
Jeśli chcesz rozszerzyć narzędzie `kubectl`, przeczytaj [Rozszerzanie kubectl za pomocą wtyczek](https://kubernetes.io/docs/tasks/extend-kubectl/kubectl-plugins/)\
.\
\
Rozszerzenia API[](https://kubernetes.io/pl/docs/concepts/_print/#api-extensions)\
\
----------------------------------------------------------------------------------\
\
### Definicje zasobów niestandardowych (ang. custom resource)[](https://kubernetes.io/pl/docs/concepts/_print/#custom-resource-definitions)\
\
Rozważ dodanie _Custom Resource_ do Kubernetesa, jeśli chcesz zdefiniować nowe kontrolery, obiekty konfiguracji aplikacji lub inne deklaratywne interfejsy API i zarządzać nimi za pomocą narzędzi Kubernetesa, takich jak `kubectl`.\
\
Aby dowiedzieć się więcej o zasobach niestandardowych, zapoznaj się z przewodnikiem po [zasobach niestandardowych](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)\
.\
\
### Warstwa agregacji API[](https://kubernetes.io/pl/docs/concepts/_print/#api-aggregation-layer)\
\
Możesz użyć [warstwy agregacji API](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/)\
Kubernetesa, aby zintegrować API Kubernetesa z dodatkowymi usługami, takimi jak [metryki](https://kubernetes.io/docs/tasks/debug/debug-cluster/resource-metrics-pipeline/)\
.\
\
### Łączenie nowych interfejsów API z automatyzacją[](https://kubernetes.io/pl/docs/concepts/_print/#combining-new-apis-with-automation)\
\
Kombinacja niestandardowego API zasobu i pętli sterowania nazywana jest wzorcem [controllers](https://kubernetes.io/pl/docs/concepts/architecture/controller/)\
. Jeśli Twój kontroler zastępuje ludzkiego operatora wdrażającego infrastrukturę na podstawie pożądanego stanu, kontroler może również podążać za [wzorcem operatora](https://kubernetes.io/pl/docs/concepts/extend-kubernetes/operator/)\
. Wzorzec operatora jest używany do zarządzania specyficznymi aplikacjami; zazwyczaj są to aplikacje, które utrzymują stan i wymagają uwagi w sposobie zarządzania nimi.\
\
Możesz także tworzyć własne niestandardowe interfejsy API i pętle sterujące, które zarządzają innymi zasobami, takimi jak storage, lub definiować polityki (takie jak ograniczenia kontroli dostępu).\
\
### Zmiana wbudowanych zasobów[](https://kubernetes.io/pl/docs/concepts/_print/#changing-built-in-resources)\
\
Kiedy rozszerzasz API Kubernetesa poprzez dodanie zasobów niestandardowych, dodane zasoby zawsze trafiają do nowych grup API. Nie możesz zastąpić ani zmienić istniejących grup API. Dodanie API nie pozwala bezpośrednio wpłynąć na zachowanie istniejących API (takich jak Pody), podczas gdy _Rozszerzenia Dostępu do API_ mogą to zrobić.\
\
Rozszerzenia dostępu do API[](https://kubernetes.io/pl/docs/concepts/_print/#api-access-extensions)\
\
----------------------------------------------------------------------------------------------------\
\
Gdy żądanie trafia do serwera API Kubernetesa, najpierw jest _uwierzytelniane_, następnie _autoryzowane_, i podlega różnym typom _kontroli dostępu_ (niektóre żądania nie są uwierzytelniane i podlegają specjalnemu przetwarzaniu). Zobacz [Kontrolowanie dostępu do API Kubernetesa](https://kubernetes.io/docs/concepts/security/controlling-access/)\
aby dowiedzieć się więcej o tym procesie.\
\
Każdy z kroków w przepływie uwierzytelniania / autoryzacji Kubernetesa oferuje punkty rozszerzeń.\
\
### Uwierzytelnianie[](https://kubernetes.io/pl/docs/concepts/_print/#authentication)\
\
[Uwierzytelnianie](https://kubernetes.io/docs/reference/access-authn-authz/authentication/)\
mapuje nagłówki lub certyfikaty we wszystkich żądaniach do nazwy użytkownika dla klienta składającego żądanie.\
\
Kubernetes ma kilka wbudowanych metod uwierzytelniania, które obsługuje. Może również działać za proxy uwierzytelniającym, a także może wysyłać token z nagłówka `Authorization:` do zdalnej usługi w celu weryfikacji (przez [authentication webhook](https://kubernetes.io/docs/reference/access-authn-authz/authentication/#webhook-token-authentication)\
), jeśli te metody nie spełniają Twoich potrzeb.\
\
### Autoryzacja[](https://kubernetes.io/pl/docs/concepts/_print/#authorization)\
\
[Authorization](https://kubernetes.io/docs/reference/access-authn-authz/authorization/)\
określa, czy konkretni użytkownicy mogą odczytywać, zapisywać i wykonywać inne operacje na zasobach API. Działa na poziomie całych zasobów -- nie rozróżnia na podstawie dowolnych pól obiektu.\
\
Jeśli wbudowane opcje autoryzacji nie spełniają Twoich potrzeb, [webhook autoryzacji](https://kubernetes.io/docs/reference/access-authn-authz/webhook/)\
umożliwia wywołanie niestandardowego kodu, który podejmuje decyzję autoryzacyjną.\
\
### Dynamiczne sterowanie dostępem[](https://kubernetes.io/pl/docs/concepts/_print/#dynamic-admission-control)\
\
Po autoryzacji żądania, jeśli jest to operacja zapisu, przechodzi również przez kroki [Kontroli Przyjęć (ang. Admission Control)](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)\
. Oprócz wbudowanych kroków, istnieje kilka rozszerzeń:\
\
* [Webhook polityki obrazów](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/#imagepolicywebhook)\
ogranicza, jakie obrazy mogą być uruchamiane w kontenerach.\
* Aby podejmować dowolne decyzje dotyczące kontroli dostępu, można użyć ogólnego [webhooka dopuszczenia (ang. Admission webhook)](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/#admission-webhooks)\
. Webhooki dopuszczenia mogą odrzucać żądania tworzenia lub aktualizacji. Niektóre webhooki modyfikują dane przychodzącego żądania, zanim zostaną one dalej obsłużone przez Kubernetesa.\
\
Rozszerzenia infrastruktury[](https://kubernetes.io/pl/docs/concepts/_print/#infrastructure-extensions)\
\
--------------------------------------------------------------------------------------------------------\
\
### Wtyczki urządzeń[](https://kubernetes.io/pl/docs/concepts/_print/#device-plugins)\
\
_Device plugins_ pozwalają węzłowi na odkrywanie nowych zasobów Węzła (oprócz wbudowanych, takich jak CPU i pamięć) za pomocą [Device Plugin](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins/)\
.\
\
### Wtyczki magazynowe (ang. Storage plugins)[](https://kubernetes.io/pl/docs/concepts/_print/#storage-plugins)\
\
Wtyczki [Container Storage Interface](https://kubernetes.io/pl/docs/concepts/storage/volumes/#csi)\
(CSI) dostarczają sposób na rozszerzenie Kubernetesa o wsparcie dla nowych rodzajów wolumenów. Wolumeny mogą być obsługiwane przez trwałe zewnętrzne magazyny danych, dostarczać pamięć ulotną lub oferować interfejs tylko do odczytu do informacji z wykorzystaniem paradygmatu systemu plików.\
\
Kubernetes zawiera również wsparcie dla wtyczek [FlexVolume](https://kubernetes.io/docs/concepts/storage/volumes/#flexvolume)\
, które są przestarzałe od wersji Kubernetes v1.23 (na rzecz CSI).\
\
Wtyczki FlexVolume umożliwiają użytkownikom podłączanie typów woluminów, które nie są natywnie obsługiwane przez Kubernetesa. Kiedy uruchamiasz Pod, który polega na magazynie FlexVolume, kubelet wywołuje wtyczkę binarną, aby zamontować wolumin. Zarchiwizowany [FlexVolume](https://git.k8s.io/design-proposals-archive/storage/flexvolume-deployment.md)\
projekt wstępny zawiera więcej szczegółów na temat tego podejścia.\
\
[FAQ dotyczące Wtyczki Wolumenów Kubernetesa dla Dostawców Pamięci](https://github.com/kubernetes/community/blob/master/sig-storage/volume-plugin-faq.md#kubernetes-volume-plugin-faq-for-storage-vendors)\
zawiera ogólne informacje na temat wtyczek do pamięci.\
\
### Wtyczki sieciowe[](https://kubernetes.io/pl/docs/concepts/_print/#network-plugins)\
\
Twój klaster Kubernetesa potrzebuje _wtyczki sieciowej_, aby mieć działającą sieć Podów i wspierać inne aspekty modelu sieciowego Kubernetesa.\
\
[Wtyczki sieciowe](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/)\
pozwalają Kubernetesowi na współpracę z różnymi topologiami i technologiami sieciowymi.\
\
### Wtyczki dostawcy poświadczeń obrazu dla Kubeleta[](https://kubernetes.io/pl/docs/concepts/_print/#kubelet-image-credential-provider-plugins)\
\
STATUS FUNKCJONALNOŚCI: `Kubernetes v1.26 [stable]`\
\
Dostawcy poświadczeń obrazów dla kubeleta to wtyczki dla kubeleta, które dynamicznie pobierają poświadczenia rejestru obrazów. Poświadczenia te są następnie używane podczas pobierania obrazów z rejestrów obrazów kontenerów, które odpowiadają konfiguracji.\
\
Wtyczki mogą komunikować się z zewnętrznymi usługami lub korzystać z lokalnych plików w celu uzyskania poświadczeń. W ten sposób kubelet nie musi mieć statycznych poświadczeń dla każdego rejestru i może obsługiwać różne metody i protokoły uwierzytelniania.\
\
Aby uzyskać szczegóły dotyczące konfiguracji wtyczki, zobacz [Konfigurowanie dostawcy poświadczeń obrazu kubelet](https://kubernetes.io/docs/tasks/administer-cluster/kubelet-credential-provider/)\
.\
\
Rozszerzenia harmonogramowania[](https://kubernetes.io/pl/docs/concepts/_print/#scheduling-extensions)\
\
-------------------------------------------------------------------------------------------------------\
\
Scheduler to specjalny typ kontrolera, który obserwuje pody i przypisuje pody do węzłów. Domyślny scheduler może być całkowicie zastąpiony, przy jednoczesnym dalszym korzystaniu z innych komponentów Kubernetesa, lub [wielokrotne schedulery](https://kubernetes.io/docs/tasks/extend-kubernetes/configure-multiple-schedulers/)\
mogą działać jednocześnie.\
\
Jest to duże przedsięwzięcie i prawie wszyscy użytkownicy Kubernetesa stwierdzają, że nie muszą modyfikować schedulera.\
\
Możesz kontrolować, które [wtyczki planowania](https://kubernetes.io/docs/reference/scheduling/config/#scheduling-plugins)\
są aktywne, lub kojarzyć zestawy wtyczek z różnymi nazwanymi [profilami schedulera](https://kubernetes.io/docs/reference/scheduling/config/#multiple-profiles)\
. Możesz również napisać własną wtyczkę, która integruje się z jednym lub więcej [punktami rozszerzeń](https://kubernetes.io/docs/concepts/scheduling-eviction/scheduling-framework/#extension-points)\
kube-schedulera.\
\
Wreszcie, wbudowany komponent `kube-scheduler` obsługuje [webhook](https://git.k8s.io/design-proposals-archive/scheduling/scheduler_extender.md)\
, który pozwala zdalnemu backendowi HTTP (rozszerzenie schedulera) na filtrowanie i/lub priorytetyzowanie węzłów, które kube-scheduler wybiera dla poda.\
\
#### Informacja:\
\
Za pomocą webhooka rozszerzającego harmonogram można wpływać jedynie na filtrowanie węzłów i priorytetyzację węzłów; inne punkty rozszerzenia nie są dostępne poprzez integrację webhooków.\
\
Co dalej?[](https://kubernetes.io/pl/docs/concepts/_print/#co-dalej)\
\
---------------------------------------------------------------------\
\
* Dowiedz się więcej o rozszerzeniach infrastruktury\
* [Wtyczki Urządzeń](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins/)\
\
* [Wtyczki sieciowe](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/)\
\
* Wtyczki do przechowywania CSI [storage plugins](https://kubernetes-csi.github.io/docs/)\
\
* Dowiedz się więcej o [wtyczkach kubectl](https://kubernetes.io/docs/tasks/extend-kubectl/kubectl-plugins/)\
\
* Dowiedz się więcej o [zasobach niestandardowych (ang. Custom Resources)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)\
\
* Dowiedz się więcej o [serwerach API rozszerzeń](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/)\
\
* Dowiedz się więcej o [dynamicznym kontrolowaniu dostępu](https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/)\
\
* Dowiedz się więcej o [wzorcu Operatora](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/)\
\
\
13.1 - Rozszerzanie API Kubernetesa[](https://kubernetes.io/pl/docs/concepts/_print/#pg-0af41d3bd7c785621b58b7564793396a)\
\
==========================================================================================================================\
\
Niestandardowe zasoby Kubernetesa (ang. Custom Resources) stanowią rozszerzenie API. Kubernetes udostępnia dwie metody ich integracji z klastrem:\
\
* Mechanizm [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)\
(CRD) pozwala deklaratywnie zdefiniować nowe niestandardowe API z grupą API, rodzajem i schematem, który określisz. Warstwa sterowania Kubernetesa obsługuje i zarządza przechowywaniem twojego niestandardowego zasobu. CRD pozwalają tworzyć nowe typy zasobów dla twojego klastra bez pisania i uruchamiania niestandardowego serwera API.\
* [Warstwa agregacji](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/)\
znajduje się za głównym serwerem API, który działa jako proxy. To rozwiązanie nazywa się Agregacją API (AA), które umożliwia dostarczanie implementacji dla własnych niestandardowych zasobów poprzez napisanie i wdrożenie własnego serwera API. Główny serwer API deleguje żądania do twojego serwera API, udostępniając je wszystkim jego klientom.\
\
13.2 - Rozszerzenia obliczeniowe, przechowywania danych i sieciowe[](https://kubernetes.io/pl/docs/concepts/_print/#pg-c8937cdc9df96f3328becf04f8211292)\
\
=========================================================================================================================================================\
\
Ta sekcja obejmuje rozszerzenia do Twojego klastra, które nie są częścią samego Kubernetesa. Możesz użyć tych rozszerzeń, aby ulepszyć węzły w Twoim klastrze lub zapewnić sieć łączącą Pody.\
\
* Wtyczki pamięci masowej [CSI](https://kubernetes.io/docs/concepts/storage/volumes/#csi)\
i [FlexVolume](https://kubernetes.io/docs/concepts/storage/volumes/#flexvolume)\
\
Wtyczki [Container Storage Interface](https://kubernetes.io/pl/docs/concepts/storage/volumes/#csi)\
(CSI) dostarczają sposób na rozszerzenie Kubernetesa o wsparcie dla nowych rodzajów wolumenów. Wolumeny mogą być wspierane przez trwałe zewnętrzne systemy przechowywania, mogą dostarczać pamięć ulotną, lub mogą oferować interfejs tylko do odczytu dla informacji przy użyciu paradygmatu systemu plików.\
\
Kubernetes zawiera również wsparcie dla wtyczek [FlexVolume](https://kubernetes.io/docs/concepts/storage/volumes/#flexvolume)\
, które są przestarzałe od Kubernetesa v1.23 (na rzecz CSI).\
\
Wtyczki FlexVolume pozwalają użytkownikom montować typy woluminów, które nie są natywnie obsługiwane przez Kubernetesa. Gdy uruchamiasz Pod, który polega na przechowywaniu FlexVolume, "kubelet" wywołuje binarną wtyczkę, aby zamontować wolumin. Zarchiwizowany [FlexVolume](https://git.k8s.io/design-proposals-archive/storage/flexvolume-deployment.md)\
dokument projektowy zawiera więcej szczegółów na temat tego podejścia.\
\
[FAQ dotyczące wtyczek wolumenów Kubernetesa dla dostawców pamięci masowej](https://github.com/kubernetes/community/blob/master/sig-storage/volume-plugin-faq.md#kubernetes-volume-plugin-faq-for-storage-vendors)\
zawiera ogólne informacje na temat wtyczek pamięci masowej.\
\
* [Wtyczki urządzeń](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins/)\
\
Wtyczki urządzeń umożliwiają węzłowi odkrywanie nowych funkcji węzła (dodatkowo do wbudowanych zasobów węzła, takich jak `cpu` i `memory`), oraz udostępniają te niestandardowe funkcje lokalne węzła dla Podów, które ich żądają.\
\
* [Wtyczki sieciowe](https://kubernetes.io/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/)\
\
Wtyczki sieciowe (ang. network plugins) umożliwiają Kubernetesowi obsługę różnych topologii i technologii sieciowych. Aby klaster Kubernetesa miał działającą sieć Podów i wspierał różne elementy modelu sieciowego Kubernetesa, konieczne jest zainstalowanie odpowiedniej _wtyczki sieciowej_.\
\
Kubernetes 1.35 jest kompatybilny z wtyczkami sieciowymi [CNI](https://kubernetes.io/pl/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/)\
.
---
# Event Rate Limit Configuration (v1alpha1) | Kubernetes
Event Rate Limit Configuration (v1alpha1)
=========================================
资源类型[](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#resource-types)
----------------------------------------------------------------------------------------------------------------
* [Configuration](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#eventratelimit-admission-k8s-io-v1alpha1-Configuration)
`Configuration`[](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#eventratelimit-admission-k8s-io-v1alpha1-Configuration)
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
Configuration 为 EventRateLimit 准入控制器提供配置数据。
| 字段 | 描述 |
| --- | --- |
| `apiVersion` string | `eventratelimit.admission.k8s.io/v1alpha1` |
| `kind` string | `Configuration` |
| `limits` **\[必需\]** [`[]Limit`](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#eventratelimit-admission-k8s-io-v1alpha1-Limit) | `limits` 是为所接收到的事件查询设置的限制。可以针对服务器端接收到的事件设置限制, 按逐个名字空间、逐个用户、或逐个来源+对象组合的方式均可以。 至少需要设置一种限制。 |
`Limit`[](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#eventratelimit-admission-k8s-io-v1alpha1-Limit)
---------------------------------------------------------------------------------------------------------------------------------------------------
**出现在:**
* [Configuration](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#eventratelimit-admission-k8s-io-v1alpha1-Configuration)
`Limit` 是为特定限制类型提供的配置数据。
| 字段 | 描述 |
| --- | --- |
| `type` **\[必需\]** [`LimitType`](https://kubernetes.io/zh-cn/docs/reference/config-api/apiserver-eventratelimit.v1alpha1/#eventratelimit-admission-k8s-io-v1alpha1-LimitType) | `type` 是此配置所适用的限制的类型。 |
| `qps` **\[必需\]** `int32` | `qps` 是针对此类型的限制每秒钟所允许的事件查询次数。qps 和 burst 字段一起用来确定是否特定的事件查询会被接受。qps 确定的是当超出查询数量的 burst 值时可以接受的查询个数。 |
| `burst` **\[必需\]** `int32` | burst 是针对此类型限制的突发事件查询数量。qps 和 burst 字段一起使用可用来确定特定的事件查询是否被接受。 burst 字段确定针对特定的事件桶(bucket)可以接受的规模上限。 例如,如果 burst 是 10,qps 是 3,那么准入控制器会在接收 10 个查询之后阻塞所有查询。 每秒钟可以额外允许 3 个查询。如果这一限额未被用尽,则剩余的限额会被顺延到下一秒钟, 直到再次达到 10 个限额的上限。 |
| `cacheSize` `int32` | `cacheSize` 是此类型限制的 LRU 缓存的规模。如果某个事件桶(bucket)被从缓存中剔除, 该事件桶所对应的限额也会被重置。如果后来再次收到针对某个已被剔除的事件桶的查询, 则该事件桶会重新以干净的状态进入缓存,因而获得全量的突发查询配额。