Learn Kubernetes Basics

Get Started

Ready to get your hands dirty? Build a simple Kubernetes cluster that runs "Hello World" for Node.js.

Documentation

Learn how to use Kubernetes with conceptual, tutorial, and reference documentation. You can even help contribute to the docs!

Blog

Read the latest news for Kubernetes and the containers space in general, and get technical how-tos hot off the presses.

Interested in hacking on the core Kubernetes code base?

View On GitHub

Explore the community

Tasks

Kubernetes v1.14 documentation is no longer actively maintained. The version you are currently viewing is a static snapshot. For up-to-date documentation, see the latest version.

Install Tools

Install and Set Up kubectl

Install Minikube

Administer a Cluster

Administration with kubeadm

Certificate Management with kubeadm

Upgrading kubeadm clusters from v1.11 to v1.12

Upgrading kubeadm clusters from v1.12 to v1.13

Upgrading kubeadm clusters from v1.13 to v1.14

Upgrading kubeadm HA clusters from v1.11 to v1.12

Upgrading kubeadm HA clusters from v1.12 to v1.13

Manage Memory, CPU, and API Resources

Configure Default Memory Requests and Limits for a Namespace

Configure Default CPU Requests and Limits for a Namespace

Configure Minimum and Maximum Memory Constraints for a Namespace

Configure Minimum and Maximum CPU Constraints for a Namespace

Configure Memory and CPU Quotas for a Namespace

Configure a Pod Quota for a Namespace

Install a Network Policy Provider

Use Calico for NetworkPolicy

Use Cilium for NetworkPolicy

Use Kube-router for NetworkPolicy

Romana for NetworkPolicy

Weave Net for NetworkPolicy

Access Clusters Using the Kubernetes API

Access Services Running on Clusters

Advertise Extended Resources for a Node

Autoscale the DNS Service in a Cluster

Change the default StorageClass

Change the Reclaim Policy of a PersistentVolume

Cluster Management

Configure Multiple Schedulers

Configure Out Of Resource Handling

Configure Quotas for API Objects

Control CPU Management Policies on the Node

Customizing DNS Service

Debugging DNS Resolution

Declare Network Policy

Developing Cloud Controller Manager

Encrypting Secret Data at Rest

Guaranteed Scheduling For Critical Add-On Pods

IP Masquerade Agent User Guide

Kubernetes Cloud Controller Manager

Limit Storage Consumption

Namespaces Walkthrough

Operating etcd clusters for Kubernetes

Reconfigure a Node's Kubelet in a Live Cluster

Reserve Compute Resources for System Daemons

Safely Drain a Node while Respecting the PodDisruptionBudget

Securing a Cluster

Set Kubelet parameters via a config file

Set up High-Availability Kubernetes Masters

Share a Cluster with Namespaces

Using a KMS provider for data encryption

Using CoreDNS for Service Discovery

Using sysctls in a Kubernetes Cluster

Configure Pods and Containers

Assign Memory Resources to Containers and Pods

Assign CPU Resources to Containers and Pods

Configure GMSA for Windows pods and containers

Configure Quality of Service for Pods

Assign Extended Resources to a Container

Configure a Pod to Use a Volume for Storage

Configure a Pod to Use a PersistentVolume for Storage

Configure a Pod to Use a Projected Volume for Storage

Configure a Security Context for a Pod or Container

Configure Service Accounts for Pods

Pull an Image from a Private Registry

Configure Liveness and Readiness Probes

Assign Pods to Nodes

Configure Pod Initialization

Attach Handlers to Container Lifecycle Events

Configure a Pod to Use a ConfigMap

Share Process Namespace between Containers in a Pod

Translate a Docker Compose File to Kubernetes Resources

Manage Kubernetes Objects

Declarative Management of Kubernetes Objects Using Configuration Files

Declarative Management of Kubernetes Objects Using Kustomize

Managing Kubernetes Objects Using Imperative Commands

Imperative Management of Kubernetes Objects Using Configuration Files

Inject Data Into Applications

Define a Command and Arguments for a Container

Define Environment Variables for a Container

Expose Pod Information to Containers Through Environment Variables

Expose Pod Information to Containers Through Files

Distribute Credentials Securely Using Secrets

Inject Information into Pods Using a PodPreset

Run Applications

Run a Stateless Application Using a Deployment

Run a Single-Instance Stateful Application

Run a Replicated Stateful Application

Update API Objects in Place Using kubectl patch

Scale a StatefulSet

Delete a StatefulSet

Force Delete StatefulSet Pods

Perform Rolling Update Using a Replication Controller

Horizontal Pod Autoscaler

Horizontal Pod Autoscaler Walkthrough

Specifying a Disruption Budget for your Application

Run Jobs

Running Automated Tasks with a CronJob

Parallel Processing using Expansions

Coarse Parallel Processing Using a Work Queue

Fine Parallel Processing Using a Work Queue

Access Applications in a Cluster

Web UI (Dashboard)

Accessing Clusters

Configure Access to Multiple Clusters

Use Port Forwarding to Access Applications in a Cluster

Use a Service to Access an Application in a Cluster

Connect a Front End to a Back End Using a Service

Create an External Load Balancer

Configure Your Cloud Provider's Firewalls

List All Container Images Running in a Cluster

Set up Ingress on Minikube with the NGINX Ingress Controller

Communicate Between Containers in the Same Pod Using a Shared Volume

Configure DNS for a Cluster

Monitoring, Logging, and Debugging

Application Introspection and Debugging

Debug a StatefulSet

Debug Init Containers

Debug Pods and ReplicationControllers

Debugging Kubernetes nodes with crictl

Determine the Reason for Pod Failure

Developing and debugging services locally

Events in Stackdriver

Get a Shell to a Running Container

Logging Using Elasticsearch and Kibana

Logging Using Stackdriver

Monitor Node Health

Resource metrics pipeline

Tools for Monitoring Resources

Troubleshoot Applications

Troubleshoot Clusters

Troubleshooting

Extend Kubernetes

Configure the Aggregation Layer

Use Custom Resources

Extend the Kubernetes API with CustomResourceDefinitions

Versions of CustomResourceDefinitions

Setup an Extension API Server

Use an HTTP Proxy to Access the Kubernetes API

TLS

Certificate Rotation

Manage TLS Certificates in a Cluster

Federation

Set up Cluster Federation with Kubefed

Set up CoreDNS as DNS provider for Cluster Federation

Set up placement policies in Federation

Cross-cluster Service Discovery using Federated Services

Administer Federation Control Plane

Federated Cluster

Federated ConfigMap

Federated DaemonSet

Federated Deployment

Federated Events

Federated Horizontal Pod Autoscalers (HPA)

Federated Ingress

Federated Namespaces

Federated ReplicaSets

Federated Secrets

Manage Cluster Daemons

Perform a Rolling Update on a DaemonSet

Perform a Rollback on a DaemonSet

Install Service Catalog

Install Service Catalog using Helm

Install Service Catalog using SC

Extend kubectl with plugins

Manage HugePages

Install Service Catalog using Helm

Service Catalog is an extension API that enables applications running in Kubernetes clusters to easily use external managed software offerings, such as a datastore service offered by a cloud provider.

It provides a way to list, provision, and bind with external Managed ServicesA software offering maintained by a third-party provider. from Service BrokersAn endpoint for a set of Managed Services offered and maintained by a third-party. without needing detailed knowledge about how those services are created or managed.

Use Helm to install Service Catalog on your Kubernetes cluster. Up to date information on this process can be found at the kubernetes-incubator/service-catalog repo.

Before you begin
Add the service-catalog Helm repository
Enable RBAC
Install Service Catalog in your Kubernetes cluster
What's next

Before you begin

Understand the key concepts of Service Catalog.
Service Catalog requires a Kubernetes cluster running version 1.7 or higher.
You must have a Kubernetes cluster with cluster DNS enabled.
- If you are using a cloud-based Kubernetes cluster or MinikubeA tool for running Kubernetes locally. , you may already have cluster DNS enabled.
- If you are using hack/local-up-cluster.sh, ensure that the KUBE_ENABLE_CLUSTER_DNS environment variable is set, then run the install script.
Install and setup kubectl v1.7 or higher. Make sure it is configured to connect to the Kubernetes cluster.
Install Helm v2.7.0 or newer.
- Follow the Helm install instructions.
- If you already have an appropriate version of Helm installed, execute helm init to install Tiller, the server-side component of Helm.

Add the service-catalog Helm repository

Once Helm is installed, add the service-catalog Helm repository to your local machine by executing the following command:

helm repo add svc-cat https://svc-catalog-charts.storage.googleapis.com

Check to make sure that it installed successfully by executing the following command:

helm search service-catalog

If the installation was successful, the command should output the following:

NAME            VERSION DESCRIPTION
svc-cat/catalog 0.0.1   service-catalog API server and controller-manag...

Enable RBAC

Your Kubernetes cluster must have RBAC enabled, which requires your Tiller Pod(s) to have cluster-admin access.

When using Minikube v0.25 or older, you must run Minikube with RBAC explicitly enabled:

minikube start --extra-config=apiserver.Authorization.Mode=RBAC

When using Minikube v0.26+, run:

minikube start

With Minikube v0.26+, do not specify --extra-config. The flag has since been changed to –extra-config=apiserver.authorization-mode and Minikube now uses RBAC by default. Specifying the older flag may cause the start command to hang.

If you are using hack/local-up-cluster.sh, set the AUTHORIZATION_MODE environment variable with the following values:

AUTHORIZATION_MODE=Node,RBAC hack/local-up-cluster.sh -O

By default, helm init installs the Tiller Pod into the kube-system namespace, with Tiller configured to use the default service account.

Note: If you used the --tiller-namespace or --service-account flags when running helm init, the --serviceaccount flag in the following command needs to be adjusted to reference the appropriate namespace and ServiceAccount name.

Configure Tiller to have cluster-admin access:

kubectl create clusterrolebinding tiller-cluster-admin \
    --clusterrole=cluster-admin \
    --serviceaccount=kube-system:default

Install Service Catalog in your Kubernetes cluster

Install Service Catalog from the root of the Helm repository using the following command:

helm install svc-cat/catalog \
    --name catalog --namespace catalog

What's next

View sample service brokers.
Explore the kubernetes-incubator/service-catalog project.

Feedback

Was this page helpful?

Thanks for the feedback. If you have a specific, answerable question about how to use Kubernetes, ask it on Stack Overflow. Open an issue in the GitHub repo if you want to report a problem or suggest an improvement.