Skip to content
Back to search

kubernetes-skill

MarketplaceWorks with Claude CodeGitHub

Practical Kubernetes skill focused on security, reliability, and low-hallucination manifest generation. Diagnoses failure modes before generating YAML.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lukasniessen-kubernetes-skill/badge.svg)](/listings/lukasniessen-kubernetes-skill)

HTML

<a href="/listings/lukasniessen-kubernetes-skill"><img src="/api/listings/lukasniessen-kubernetes-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1: Skills CLI

If you manage skills with the `skills` CLI, install KubeShark directly from GitHub:

npx skills add https://github.com/lukasniessen/kubernetes-skill --skill kubernetes-skill

Option 2: Clone

**macOS / Linux:**

git clone https://github.com/LukasNiessen/kubernetes-skill.git ~/.claude/skills/kubernetes-skill

**Windows (Powershell):**

git clone https://github.com/LukasNiessen/kubernetes-skill.git "$env:USERPROFILE\.claude\skills\kubernetes-skill"

**Windows (Command Prompt):**

git clone https://github.com/LukasNiessen/kubernetes-skill.git "%USERPROFILE%\.claude\skills\kubernetes-skill"

That's it. Claude Code auto-discovers skills in `~/.claude/skills/` -- no restart needed.

Option 3: Marketplace

Claude Code has a built-in plugin system with marketplace support. Instead of cloning manually, you can add KubeShark's marketplace and install directly from the CLI:

/plugin marketplace add LukasNiessen/kubernetes-skill
/plugin install kubernetes-skill

Or use the interactive plugin manager -- run `/plugin`, switch to the **Discover** tab, and install from there. The marketplace reads the `.claude-plugin/marketplace.json` in this repo to register KubeShark as an installable plugin.

Option 4: Codex

Codex has no global skill system -- setup is per-project. Clone KubeShark into your repo and reference it from your `AGENTS.md`:

# Clone into your project root
git clone https://github.com/LukasNiessen/kubernetes-skill.git .kubernetes-skill

Then add to your `AGENTS.md` (or create one in the repo root):

## Kubernetes

When working with Kubernetes manifests, Helm charts, or Kustomize overlays, follow the workflow in `.kubernetes-skill/SKILL.md`.
Load references from `.kubernetes-skill/references/` as needed.

That's it!

Done. Now ask Claude Code / Codex any Kubernetes question. KubeShark responses follow the 7-step failure-mode workflow and include an output contract with assumptions, tradeoffs, and rollback notes.

**Invoke explicitly:**

/kubernetes-skill Create a production-ready Deployment with an Ingress and autoscaling
/kubernetes-skill Review my Deployment for security issues and add proper RBAC, NetworkPolicies, and resource limits

**Or just ask naturally** -- KubeShark activates automatically for any Kubernetes task:

Review my deployment.yaml for security issues
Create a Helm chart for a PostgreSQL StatefulSet with backup CronJobs

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "kubernetes-skill",
  3. "description": "Practical Kubernetes skill focused on security, reliability, and low-hallucination manifest generation. Diagnoses failure modes before generating YAML.",
  4. "owner": {
  5. "name": "LukasNiessen"
  6. },
  7. "plugins": [
  8. {
  9. "name": "kubernetes-skill",
  10. "source": "./",
  11. "description": "Kubernetes Guardrails — KubeShark",
  12. "version": "1.0.0"
  13. }
  14. ]
  15. }
README.md · README · 355 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Kubernetes Skill for Claude Code and Codex: KubeShark
  2. <div align="center" name="top">
  3. <img align="center" src="assets/logo.png" width="180" height="180" alt="KubeShark Logo">
  4. <!-- spacer -->
  5. <p></p>
  6. [![Claude Skill](https://img.shields.io/badge/Claude-Skill-6272F5)](https://docs.claude.ai/docs/agent-skills)
  7. [![Codex Skill](https://img.shields.io/badge/Codex-Skill-10A37F)](https://developers.openai.com/codex/skills/)
  8. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  9. [![GitHub stars](https://img.shields.io/github/stars/LukasNiessen/kubernetes-skill.svg)](https://github.com/LukasNiessen/kubernetes-skill)
  10. </div>
  11. The #1 Kubernetes skill for Claude Code and Codex, measured by GitHub stars.
  12. ### Fixes Hallucinations.
  13. LLMs hallucinate a lot when it comes to Kubernetes. They omit security contexts, generate deprecated APIs, use wildcard RBAC, forget resource limits, and produce probes that cause cascading failures. This skill fixes it. It includes best practices for Kubernetes -- good, bad, and neutral examples so the AI avoids common mistakes. Using KubeShark, the AI keeps proven practices in mind, eliminates hallucinations, and defaults to secure, reliable, production-ready manifests.
  14. KubeShark is built as the production-grade Kubernetes skill for Claude Code and Codex: broader than resource-template skills, safer than generic Kubernetes prompts, and tuned for hallucination prevention instead of raw tutorial volume.
  15. ### Very Token-Efficient.
  16. Most Kubernetes skills dump huge walls of text onto the agent and burn expensive tokens -- with no upside. LLMs don't need the entire Kubernetes docs again. KubeShark was aggressively de-duplicated and optimized for maximum quality per token.
  17. ### Based on Official Best Practices.
  18. KubeShark is primarily based on the [official Kubernetes documentation](https://kubernetes.io/docs/), the [NSA/CISA Kubernetes Hardening Guide](https://media.defense.gov/2022/Aug/29/2003066362/-1/-1/0/CTR_KUBERNETES_HARDENING_GUIDANCE_1.2_20220829.PDF), [OWASP Kubernetes Top 10](https://owasp.org/www-project-kubernetes-top-ten/), [Pod Security Standards](https://kubernetes.io/docs/concepts/security/pod-security-standards/), and the [CIS Kubernetes Benchmark](https://www.cisecurity.org/benchmark/kubernetes). When guidance conflicts, it prioritizes official Kubernetes documentation.
  19. ---
  20. [Quick Start](#-quick-start) · [Why KubeShark](#-why-kubeshark) · [Token Strategy](#-token-strategy) · [What's Included](#-whats-included) · [How It Works](#-how-it-works) · [Sponsor](https://github.com/sponsors/LukasNiessen) · [Philosophy](PHILOSOPHY.md)
  21. ---
  22. ## 2 min Quickstart
  23. ### Option 1: Skills CLI
  24. If you manage skills with the `skills` CLI, install KubeShark directly from GitHub:
  25. ```bash
  26. npx skills add https://github.com/lukasniessen/kubernetes-skill --skill kubernetes-skill
  27. ```
  28. ### Option 2: Clone
  29. **macOS / Linux:**
  30. ```bash
  31. git clone https://github.com/LukasNiessen/kubernetes-skill.git ~/.claude/skills/kubernetes-skill
  32. ```
  33. **Windows (Powershell):**
  34. ```powershell
  35. git clone https://github.com/LukasNiessen/kubernetes-skill.git "$env:USERPROFILE\.claude\skills\kubernetes-skill"
  36. ```
  37. **Windows (Command Prompt):**
  38. ```powershell
  39. git clone https://github.com/LukasNiessen/kubernetes-skill.git "%USERPROFILE%\.claude\skills\kubernetes-skill"
  40. ```
  41. That's it. Claude Code auto-discovers skills in `~/.claude/skills/` -- no restart needed.
  42. ### Option 3: Marketplace
  43. Claude Code has a built-in plugin system with marketplace support. Instead of cloning manually, you can add KubeShark's marketplace and install directly from the CLI:
  44. ```
  45. /plugin marketplace add LukasNiessen/kubernetes-skill
  46. /plugin install kubernetes-skill
  47. ```
  48. Or use the interactive plugin manager -- run `/plugin`, switch to the **Discover** tab, and install from there. The marketplace reads the `.claude-plugin/marketplace.json` in this repo to register KubeShark as an installable plugin.
  49. ### Option 4: Codex
  50. Codex has no global skill system -- setup is per-project. Clone KubeShark into your repo and reference it from your `AGENTS.md`:
  51. ```bash
  52. # Clone into your project root
  53. git clone https://github.com/LukasNiessen/kubernetes-skill.git .kubernetes-skill
  54. ```
  55. Then add to your `AGENTS.md` (or create one in the repo root):
  56. ```markdown
  57. ## Kubernetes
  58. When working with Kubernetes manifests, Helm charts, or Kustomize overlays, follow the workflow in `.kubernetes-skill/SKILL.md`.
  59. Load references from `.kubernetes-skill/references/` as needed.
  60. ```
  61. ### That's it!
  62. Done. Now ask Claude Code / Codex any Kubernetes question. KubeShark responses follow the 7-step failure-mode workflow and include an output contract with assumptions, tradeoffs, and rollback notes.
  63. **Invoke explicitly:**
  64. ```bash
  65. /kubernetes-skill Create a production-ready Deployment with an Ingress and autoscaling
  66. ```
  67. ```bash
  68. /kubernetes-skill Review my Deployment for security issues and add proper RBAC, NetworkPolicies, and resource limits
  69. ```
  70. **Or just ask naturally** -- KubeShark activates automatically for any Kubernetes task:
  71. ```
  72. Review my deployment.yaml for security issues
  73. ```
  74. ```
  75. Create a Helm chart for a PostgreSQL StatefulSet with backup CronJobs
  76. ```
  77. ## Why KubeShark
  78. ### Overview
  79. | Dimension | **KubeShark** | **No Skill** |
  80. | ------------------------------- | ------------------------------------------------------ | ------------ |
  81. | **SKILL.md activation cost** | Low, procedural workflow only | 0 |
  82. | **Reference granularity** | 26 focused files | -- |
  83. | **Token burn per query** | Low (load only matched refs) | 0 |
  84. | **Architecture** | Failure-mode workflow | -- |
  85. | **Diagnoses before generating** | Yes (Step 2) | No |
  86. | **Output contract** | Yes -- assumptions, tradeoffs, rollback | No |
  87. | **Conditional references** | EKS, GKE, AKS, OpenShift, GitOps, observability stacks | No |
  88. | **Security-first defaults** | PSS restricted profile | No |
  89. | **Good/bad examples** | Yes (2 dedicated files) | No |
  90. | **Do/Don't checklist** | Yes (dedicated file) | No |
  91. | **Compliance coverage** | NSA/CISA, OWASP K8s Top 10, CIS, Pod Security Standards | No |
  92. | **Hallucination prevention** | Core design goal | No |
  93. | **Cross-resource validation** | Label/selector/port consistency checks | No |
  94. | **Helm/Kustomize guidance** | Dedicated reference files | No |
  95. | **Policy engine integration** | Kyverno and OPA/Gatekeeper patterns | No |
  96. | **License** | MIT | -- |
  97. ### Why Failure-Mode-First Matters for Kubernetes
  98. The key insight is architectural. A static reference manual gives Claude information but never tells it _how to think_ about a problem. There's no diagnosis step, no risk assessment, and no structured output -- Claude reads the reference and generates whatever it thinks fits.
  99. KubeShark takes the opposite approach. The core SKILL.md is a compact operational workflow. It forces Claude through a diagnostic sequence: capture context -> identify failure modes -> load _only_ the relevant references -> propose fixes with explicit risk controls -> validate -> deliver a structured output contract.
  100. This matters for Kubernetes specifically because:
  101. 1. **Silent failures are common.** A Service with the wrong selector deploys successfully but routes to nothing. A NetworkPolicy with a mistyped label silently does nothing. Unlike Terraform, Kubernetes accepts most manifests without error -- failures surface at runtime.
  102. 2. **Multi-dimensional risk.** Kubernetes operates across security, networking, scheduling, storage, and application lifecycle simultaneously. An LLM must reason about all these dimensions for every resource.
  103. 3. **Training data pollution.** Kubernetes has had aggressive API deprecation. The LLM training corpus contains vast amounts of pre-1.22 YAML using removed APIs. Without diagnosis, the LLM confidently generates deprecated configurations.
  104. ### Skill Comparison
  105. Here's how KubeShark compares to other public Kubernetes-focused agent skills found during the May 2026 review. This compares Kubernetes skill behavior, not full runtime observability products or broad skill collections.
  106. | Dimension | **KubeShark** | **Kubernetes Resource Management** | **Kube Audit Kit** | **Kubernetes Operations** |
  107. | --------------------------------- | -------------------------------------------------- | ---------------------------------- | ---------------------------------- | ---------------------------------- |
  108. | **Primary goal** | Generate, review, refactor, and harden K8s safely | Explain and template core objects | Read-only cluster security audits | Kubectl operations and debugging |
  109. | **Failure-mode workflow** | Yes: six explicit Kubernetes failure modes | No | Audit workflow only | Partial operational workflow |
  110. | **Manifest generation/review** | Yes | Yes | No, audit-focused | Yes |
  111. | **Helm/Kustomize guidance** | Dedicated references | No dedicated coverage | No | Not primary |
  112. | **Platform-specific guidance** | EKS, GKE, AKS, OpenShift via CRR | No | No | Cloud-aware, less granular |
  113. | **GitOps and observability depth** | Argo CD, Flux, Prometheus, OpenTelemetry, Loki | No | No | No |
  114. | **Security posture** | PSS restricted defaults, RBAC, policy engines | Basic resource guidance | Strong audit focus | General stability/security |
  115. | **Cross-resource validation** | Label, selector, port, policy, and rollout checks | Basic examples | Post-export analysis | Operational troubleshooting |
  116. | **Output contract** | Assumptions, tradeoffs, validation, rollback | No | Audit report | No structured contract |
  117. | **Token strategy** | Lean workflow plus conditional references | Single static resource guide | Scripted audit skill | Operational guidance |
  118. KubeShark wins on production manifest work because it diagnoses before generating, keeps platform depth behind CRR, covers Helm/Kustomize and policy engines, and forces validation plus rollback into the response contract.
  119. ---
  120. ## Token Strategy
  121. - Keep `SKILL.md` procedural and compact
  122. - Keep references focused on failure-prone decisions
  123. - Exclude broad tutorial material with low safety impact
  124. - Add depth only when measured quality would otherwise drop
  125. - Use Conditional Reference Retrieval (CRR) for platform and controller specifics
  126. ## Conditional Reference Retrieval (CRR)
  127. Conditional Reference Retrieval is context-gated reference loading. It is a skill-specific form of progressive disclosure: the workflow first captures signals from the request or repository, then loads only the reference files whose conditions match.
  128. This keeps common Kubernetes work lean. A plain Deployment review does not pay the token cost for EKS, GKE, AKS, OpenShift, GitOps, or observability-stack guidance. If the task mentions one of those platforms or controllers, KubeShark pulls in the matching reference and keeps the rest out of context.
  129. CRR files live under `references/conditional/`. The directory name is intentionally plain-language; CRR is the mechanism, `conditional` is the repository convention.
  130. | Signal detected | CRR reference | Purpose |
  131. | ----------------------------------------- | ---------------------------------------------- | ----------------------------------------------------------- |
  132. | EKS, AWS, IRSA, EKS Pod Identity, Karpenter | `references/conditional/eks-patterns.md` | AWS identity, load balancing, storage, CNI, node provisioning |
  133. | GKE, Autopilot, Workload Identity, Dataplane V2 | `references/conditional/gke-patterns.md` | GKE identity, Autopilot constraints, networking, storage |
  134. | AKS, Entra Workload ID, Azure CNI, AGIC | `references/conditional/aks-patterns.md` | Azure identity, CNI, ingress, and CSI storage |
  135. | OpenShift, OKD, ROSA, ARO, Routes, SCCs | `references/conditional/openshift-patterns.md` | SCCs, Routes, arbitrary UID images, OpenShift validation |
  136. | Argo CD, Flux, ApplicationSet, GitOps | `references/conditional/gitops-controllers.md` | Reconciliation, pruning, ordering, drift, controller safety |
  137. | Prometheus Operator, ServiceMonitor, OpenTelemetry, Loki, Grafana | `references/conditional/observability-stacks.md` | Monitoring CRDs, telemetry pipelines, log and alert hygiene |
  138. ## What's Included
  139. - A focused `SKILL.md` execution flow
  140. - Failure-mode-first guidance to prevent common Kubernetes hallucinations
  141. - Core failure-mode references: insecure workload defaults, resource starvation, network exposure, privilege sprawl, fragile rollouts, API drift
  142. - Workload pattern guides for Deployments, StatefulSets, Jobs, DaemonSets
  143. - Cross-cutting concern references: security hardening, observability, multi-tenancy, storage
  144. - Helm and Kustomize best practices
  145. - Conditional Reference Retrieval for EKS, GKE, AKS, OpenShift, GitOps controllers, and observability stacks
  146. - Validation and policy engine integration (Kyverno, OPA/Gatekeeper, kubeconform)
  147. - Good/bad example banks with LLM mistake checklists
  148. - Do/Don't pattern checklist
  149. ## Repository Layout
  150. Here is an overview of the repository layout.
  151. | File | Description |
  152. | ------------------------------------------------ | -------------------------------------------------------------- |
  153. | `SKILL.md` | Operational workflow for KubeShark |
  154. | `PHILOSOPHY.md` | Design strategy, architecture decisions, token experiment |
  155. | `references/insecure-workload-defaults.md` | Security contexts, PSS profiles, capabilities |
  156. | `references/resource-starvation.md` | Requests/limits, QoS, PDB, scheduling |
  157. | `references/network-exposure.md` | NetworkPolicy, Services, Ingress, DNS |
  158. | `references/privilege-sprawl.md` | RBAC, ServiceAccounts, secret management |
  159. | `references/fragile-rollouts.md` | Probes, update strategies, image tags, graceful shutdown |
  160. | `references/api-drift.md` | apiVersion correctness, deprecations, schema validation |
  161. | `references/deployment-patterns.md` | Stateless workload patterns |
  162. | `references/stateful-patterns.md` | StatefulSet and persistent workload patterns |
  163. | `references/job-patterns.md` | Job and CronJob patterns |
  164. | `references/daemonset-operator-patterns.md` | DaemonSet and operator patterns |
  165. | `references/security-hardening.md` | NSA/CISA, OWASP, CIS controls and hardening |
  166. | `references/observability.md` | Prometheus, logging, tracing, alerting patterns |
  167. | `references/multi-tenancy.md` | Namespace isolation, quotas, tenant boundaries |
  168. | `references/storage-and-state.md` | PV/PVC, StorageClass, CSI, backup/restore |
  169. | `references/helm-patterns.md` | Helm chart structure, templates, testing |
  170. | `references/kustomize-patterns.md` | Kustomize overlays, patches, generators |
  171. | `references/validation-and-policy.md` | kubeconform, Kyverno, OPA/Gatekeeper, CI integration |
  172. | `references/conditional/eks-patterns.md` | EKS identity, load balancing, storage, CNI, Karpenter (CRR) |
  173. | `references/conditional/gke-patterns.md` | GKE identity, Autopilot, Dataplane V2, storage (CRR) |
  174. | `references/conditional/aks-patterns.md` | AKS workload identity, CNI, ingress, storage (CRR) |
  175. | `references/conditional/openshift-patterns.md` | OpenShift SCCs, Routes, arbitrary UID constraints (CRR) |
  176. | `references/conditional/gitops-controllers.md` | Argo CD, Flux, reconciliation, pruning, sync ordering (CRR) |
  177. | `references/conditional/observability-stacks.md` | Prometheus Operator, OpenTelemetry, Loki, Grafana (CRR) |
  178. | `references/examples-good.md` | Production-ready annotated examples |
  179. | `references/examples-bad.md` | Anti-pattern examples with explanations |
  180. | `references/do-dont-patterns.md` | Do/Don't quick-reference checklist |
  181. | `.github/workflows/validate.yml` | CI validation for skill structure and links |
  182. | `.github/PULL_REQUEST_TEMPLATE.md` | PR quality and failure-mode checklist |
  183. | `.claude-plugin/marketplace.json` | Plugin metadata |
  184. ## How It Works
  185. The skill runs as a failure-mode workflow whenever Claude Code handles Kubernetes tasks:
  186. 1. **Capture execution context** - Cluster version, distribution, namespace, environment, workload type, deployment method, policies
  187. 2. **Diagnose likely failure mode(s)** - Insecure workload defaults, resource starvation, network exposure, privilege sprawl, fragile rollouts, API drift
  188. 3. **Load only relevant references** - Pull targeted guidance for the failure mode(s) in scope, then apply CRR for detected platforms/controllers
  189. 4. **Propose fix path with controls** - Include risk notes, runtime behavior, tests, and rollback expectations
  190. 5. **Generate implementation artifacts** - YAML manifests, Helm charts, Kustomize overlays, RBAC, policies
  191. 6. **Validate before finalize** - Dry-run, schema validation, cross-resource consistency, policy scan
  192. 7. **Deliver complete output** - Assumptions, remediation choices, tradeoffs, validation plan, recovery notes
  193. ## Scope
  194. - Kubernetes manifest design, review, and refactoring
  195. - Helm chart and Kustomize overlay creation
  196. - RBAC, NetworkPolicy, and security hardening
  197. - Workload reliability: probes, resources, rollout strategies
  198. - Policy engine integration (Kyverno, OPA/Gatekeeper)
  199. - Platform-specific guidance for EKS, GKE, AKS, and OpenShift when detected
  200. - GitOps and observability-stack guidance when those controllers are in scope
  201. - CI validation pipelines for Kubernetes
  202. ## FAQ
  203. **Q: Does this work with all Kubernetes distributions?**
  204. Yes. KubeShark supports vanilla Kubernetes, EKS, GKE, AKS, OpenShift, k3s, and other distributions. The workflow captures cluster version and distribution first and adapts guidance accordingly. CRR loads deeper platform references only when those distributions are detected.
  205. **Q: Will this slow down my AI interactions?**
  206. No. The skill is designed for low token overhead. Only relevant references are loaded for a given failure mode.
  207. **Q: Can I use this outside Claude Code?**
  208. Yes. The references are plain Markdown and can be used from any workflow or AI assistant, **including Codex**. The trigger behavior in `SKILL.md` is optimized for skill-enabled environments.
  209. **Q: What Kubernetes versions are supported?**
  210. KubeShark targets Kubernetes 1.25+ as the baseline (all pre-1.25 deprecated APIs are flagged). Guidance is version-aware and the workflow captures cluster version in Step 1.
  211. **Q: Does this cover Helm and Kustomize?**
  212. Yes. Dedicated reference files cover Helm chart patterns and Kustomize overlay patterns, including common LLM mistakes in both tools.
  213. ## Contributing
  214. We highly appreciate contributions. See [CONTRIBUTING.md](CONTRIBUTING.md) and use the PR template for failure-mode and validation details.
  215. ## Community
  216. ### Maintainers
  217. - **[LukasNiessen](https://github.com/LukasNiessen)** - Creator and main maintainer
  218. - **[janMagnusHeimann](https://github.com/janMagnusHeimann)** - Main maintainer
  219. - **[TristanKruse](https://github.com/TristanKruse)** - Main maintainer
  220. ### Contributors
  221. <a href="https://github.com/LukasNiessen/kubernetes-skill/graphs/contributors">
  222. <img src="https://contrib.rocks/image?repo=LukasNiessen/kubernetes-skill&max=1000&contributors=10" />
  223. </a>
  224. ### Questions
  225. Found a bug? Want to discuss features?
  226. - Submit an [issue on GitHub](https://github.com/LukasNiessen/kubernetes-skill/issues/new/choose)
  227. - Join [GitHub Discussions](https://github.com/LukasNiessen/kubernetes-skill/discussions)
  228. If KubeShark helps your project, please consider:
  229. - Starring the repository
  230. - Suggesting new features
  231. - Contributing code or documentation
  232. ### Star History
  233. [![Star History Chart](https://star-history.dera.page/svg?repos=LukasNiessen/kubernetes-skill&type=Date)](https://star-history.dera.page/#LukasNiessen/kubernetes-skill&Date)
  234. ## License
  235. This project is under the **MIT** license.
  236. ---
  237. <p align="center">
  238. <a href="#top"><strong>Go Back to Top</strong></a>
  239. </p>
  240. ---
  241. ## Other
  242. **Version:** v1.0.0
  243. **GitHub Pages:** [https://lukasniessen.github.io/kubernetes-skill/](https://lukasniessen.github.io/kubernetes-skill/)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.