Want to level up your Kubernetes knowledge? Explore our tutorials and step-by-step guides written by Kubernetes experts. Learn Kubernetes best practices and solutions to the most difficult problems.

Kubernetes Guides and Tutorials | Spacelift Blog

Author title

Going to AWS Summit London? 🇬🇧🇬🇧

Title category

Get all the latest content on Infrastructure as Code, DevOps, Spacelift features & news directly to your inbox!

Level up your IaC knowledge. Stay up to date with educational devops guides & news in infrastructure as code, cloud & more!

Managing Infrastructure at Scale | Spacelift Blog

Announcing Enhanced VCS Integration  🎉 🎉

applepodcasts

spotify

missionctrl

Welcome to missionCTRL, a show dedicated to exploring the frontiers of modern DevOps. Listen (or watch) as we sit down with the practitioners who are pushing the boundaries of development

Kubernetes

Jack Roper

In this article, we will look at the <code class="gq ky kz la lb b">kubectl apply</code> and <code class="gq ky kz la lb b">kubectl create</code> commands to understand how to use them and the differences between the two. We will then look at some usage examples on an Azure Kubernetes Service cluster (AKS).
To understand the differences between the commands, we first need an understanding of declarative and imperative management. But in short, the difference between kubectl apply and kubectl create is that <code class="gq ky kz la lb b">kubectl apply</code> is best to use to take advantage of version control, while <code class="gq ky kz la lb b">kubectl create</code> is a good option if you are experimenting or troubleshooting.

Declarative management is where we specify the required outcome, not the individual steps needed to achieve that outcome.
For each kind of resource specified in our YAML configuration files, a dedicated controller checks what we currently have and tries to converge it with what we want.
<code class="gq ky kz la lb b">kubectl apply</code> — This is a declarative command.

Imperative management means giving a series of instructions or steps to reach the goal. We specify what and how we should reach the goal.
This is where we tell K8S what to create, replace, delete, etc., using the API. Objects are created and managed using the <code class="gq ky kz la lb b">kubectl</code> command on the command line interface (CLI).
<code class="gq ky kz la lb b">kubectl create</code> — This is an imperative command.

The <code>kubectl apply</code> command applies 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. If the resource already exists, this command will not error. JSON and YAML formats are accepted. The file used with the apply command can be incomplete.
<code class="gq ky kz la lb b">kubectl apply (-f FILENAME | -k DIRECTORY)</code>

The <code>kubectl create</code> command creates a resource from a file or from stdin. JSON and YAML formats are accepted. If the resource already exists, <code class="gq ky kz la lb b">kubectl create</code> will error.
<code class="gq ky kz la lb b">kubectl create -f FILENAME</code>
If you want to have all the kubectl commands in one place, check out our <a href="https://spacelift.io/blog/kubernetes-cheat-sheet" target="_blank" rel="noopener">Kubernetes Cheat Sheet</a>.

<ul>
<li><a href="https://spacelift.io/blog/provision-kubernetes-cluster-terraform-spacelift" target="_blank" rel="noopener">How to Provision Kubernetes Cluster with Terraform</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-best-practices" target="_blank" rel="noopener">15 Kubernetes Best Practices to Follow</a></li>
<li><a href="https://spacelift.io/blog/terraform-vs-kubernetes" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;Terraform vs. Kubernetes : Key Differences and Comparison&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">Terraform vs. Kubernetes Comparison</a></li>
</ul>

Below you can find a comparison <a href="https://spaceliftio.wpcomstaging.com/wp-content/uploads/2022/10/kubectl-apply-vs-create-comparison-table.png" target="_blank" rel="noopener">table</a> for these two commands.

<table class=" alignleft">
<tbody>
<tr>
<td style="text-align: center;">kubectl apply</td>
<td style="text-align: center;">kubectl create</td>
</tr>
<tr>
<td style="text-align: center;">&nbsp;
<code>kubectl apply (-f FILENAME | -k DIRECTORY)</code></td>
<td>&nbsp;
<code>kubectl create -f FILENAME</code>
</td>
</tr>
<tr>
<td>
This is a declarative command.
</td>
<td>
This is an imperative command.
</td>
</tr>
<tr>
<td>
JSON and YAML formats are accepted.
</td>
<td>
JSON and YAML formats are accepted.
</td>
</tr>
<tr>
<td>
  Applies a configuration to a resource by file name or stdin.
</td>
<td>
Creates a resource from a file or from stdin.
</td>
</tr>
<tr>
<td>
If the resource already exists, this command will not error.
</td>
<td>
If the resource already exists, this command will error.
</td>
</tr>
<tr>
<td>
Can be used to update an already existing deployment.
</td>
<td>
  Can only be used when the resource does not already exist.
</td>
</tr>
</tbody>
</table>

To further understand the two commands, take a look at the example below:
1. Create a YAML file using the demo app from the official Azure documentation.
aks-helloworld-one.yaml

2. Connect to Azure on the command line.

3. With the file in the same directory, run <code class="gq ky kz la lb b">kubectl apply</code>:

You should see the message: ‘deployment.apps/aks-helloworld-one created’.

kubernetes-apply-vs-create-aks-helloworld

kubernetes apply vs create aks helloworld

4. Check the deployment worked:

kubectl-apply-vs-create-kubectl-get-deployment

kubectl apply vs create kubectl get deployment

5. Now, we will try to deploy the same file using the <code class="gq ky kz la lb b">kubectl create</code> command.

You will see an error as the deployment already exists. This is expected behavior when using the <code class="gq ky kz la lb b">kubectl create</code> command:

kubectl-apply-vs-create-kubectl-create-error

kubectl apply vs create kubectl create error

6. We will try <code class="gq ky kz la lb b">kubectl create</code> again, with a different deployment name.

This time the deployment will be successful:

kubectl-apply-vs-create-kubectl-create

kubectl apply vs create kubectl create

7. Modify the aks-helloworld-one.yaml file to increase the number of replicas from 1 to 3 (shown below).

8. Apply the new configuration:

The output should show that the change has been configured.

kubectl-apply-vs-create-apply-config

kubectl apply vs create apply config

9. Check the deployment:

You should now see three pods running in the deployment:

kubectl-apply-vs-create-3-pods-running

kubectl apply vs create 3 pods running

You can see from the example that the <code class="gq ky kz la lb b">kubectl apply</code> command can be used to update an already existing deployment, <code class="gq ky kz la lb b">kubectl create</code> but cannot. <code class="gq ky kz la lb b">kubectl create</code> can only be used when the resource does not already exist.

Using both <code class="gq ky kz la lb b">kubectl apply</code> and <code class="gq ky kz la lb b">kubectl create</code> can be useful in different situations, depending on which deployment management method you want to use. <code class="gq ky kz la lb b">kubectl apply</code> is best to use to take advantage of version control, where if you are experimenting or troubleshooting, <code class="gq ky kz la lb b">kubectl create</code> is a good option.
You can check out the command reference for both commands on the official <a href="https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands" target="_blank" rel="nofollow noopener">kubernetes.io website</a>.
Additionally, <a href="https://spacelift.io" target="_blank" rel="noopener">Spacelift</a> can help you manage the complexities and compliance challenges of using Kubernetes. Anything that can be run via kubectl can be run within a Spacelift stack. Read more about <a href="https://docs.spacelift.io/vendors/kubernetes/" target="_blank" rel="noopener">how Spacelift works with Kubernetes</a>.
Cheers!

Spacelift is an alternative to using homegrown solutions on top of a generic CI. It helps overcome common state management issues and adds several must-have capabilities s for infrastructure management.

Kubernetes Tutorial for Beginners: Basic Concepts

Provision a Kubernetes Cluster with Spacelift and Terraform

Enable Auto-Completion for Kubectl [Bash, Zsh, PowerShell]

Using both kubectl apply and kubectl create can be useful in different situations. Take a look at the AKS usage example.

113-kubectl-apply-vs-create

kubectl apply vs create

Kubectl Apply vs. Kubectl Create - What’s the Difference?

A pod is the smallest unit in Kubernetes (K8S). They should run until they are replaced by a new deployment. Because of this, there is no way to restart a pod, instead, it should be replaced.
There is no <code>kubectl restart [podname]</code> command for use with K8S (with <a href="https://spacelift.io/blog/docker-tutorial" target="_blank" rel="noopener">Docker</a> you can use <code>docker restart [container_id]</code> ), so there are a few different ways to achieve a pod ‘restart’ with <code>kubectl</code>.

There are many situations in which you may need to restart a pod:
<ul>
<li style="font-weight: 400;" aria-level="1">Applying configuration changes → If there are updates on the pod’s configuration (configmaps, secrets, environment variables), in some cases, you may need to manually restart the pod for the changes to take effect. </li>
<li style="font-weight: 400;" aria-level="1">Debugging applications → Sometimes, if your application is not running correctly, or you are just experiencing some issues with it, a good practice is to first restart the underlying pods to reset their state and make troubleshooting easier.</li>
<li style="font-weight: 400;" aria-level="1">Pod stuck in a terminating state → In this case, usually, a delete and a recreation would do the trick in most of the cases. However, there are some cases where a node is taken out of service, and the pods cannot be evicted from it, in which a restart will help with addressing the issue.</li>
<li style="font-weight: 400;" aria-level="1">OOM → If a pod is <a href="https://spacelift.io/blog/oomkilled-exit-code-137" target="_blank" rel="noopener">terminated with an Out Of Memory Error (OOM),</a> you will need to restart the pod after making changes to the resource specifications. This may be solved automatically if the pod’s restart policy allows it.</li>
<li style="font-weight: 400;" aria-level="1">Forcing a new image pull → To ensure a pod is using the latest version of an image, if you are using the latest tag (which is not a best practice), you need to manually restart the pod to force a new image pull. Of course, if you are making changes to the image parameter in the configuration because you’ve released a new image and you want to take advantage of that, a restart will still be required.</li>
<li style="font-weight: 400;" aria-level="1">Resource contention → If a pod is consuming excessive resources, causing performance issues, or affecting other workflows, restarting the pod may release those resources and mitigate the problem. This usually occurs when you are not using memory and CPU restrictions.</li>
</ul>

A pod has five possible statuses:
<ol>
<li>Pending: This state shows at least one container within the pod has not yet been created.</li>
<li>Running: All containers have been created, and the pod has been bound to a Node. At this point, the containers are running, or are being started or restarted.</li>
<li>Succeeded: All containers in the pod have been successfully terminated and will not be restarted.</li>
<li>Failed: All containers have been terminated, and at least one container has failed. The failed container exists in a non-zero state.</li>
<li>Unknown: The status of the pod cannot be obtained.</li>
</ol>
If you notice a pod in an undesirable state where the status is showing as ‘error’, you might try a ‘restart’ as part of your troubleshooting to get things back to normal operations. You may also see the status ‘<a href="https://spacelift.io/blog/crashloopbackoff" target="_blank" rel="noopener">CrashLoopBackOff</a>’, which the default when an error is encountered, and K8S trys to restart the pod automatically.

You can use the following methods to ‘restart’ a pod with <code>kubectl</code>. Once new pods are re-created they will have a different name than the old ones. A list of pods can be obtained using the <code>kubectl get pods</code> command.

<h3>Method 1</h3>
<code>kubectl rollout restart</code>
This method is the recommended first port of call as it will not introduce downtime as pods will be functioning. A rollout restart will kill one pod at a time, then new pods will be scaled up. This method can be used as of K8S v1.15.
<code>kubectl rollout restart deployment &lt;deployment_name&gt; -n &lt;namespace&gt;</code>

<h3>Method 2</h3>
<code>kubectl scale</code>
This method will introduce an outage and is not recommended. If downtime is not an issue, this method can be used as it can be a quicker alternative to the <code>kubectl rollout restart method</code> (your pod may have to run through a lengthy Continuous Integration / Continuous Deployment Process before it is redeployed).
If there is no YAML file associated with the deployment, you can set the number of replicas to 0.
<code>kubectl scale deployment &lt;deployment name&gt; -n &lt;namespace&gt; --replicas=0</code>
This terminates the pods. Once scaling is complete the replicas can be scaled back up as needed (to at least 1):
<code>kubectl scale deployment &lt;deployment name&gt; -n &lt;namespace&gt; --replicas=3</code>
Pod status can be checked during the scaling using:
<code>kubectl get pods -n &lt;namespace&gt;</code>

<h3>Method 3</h3>
<code><a href="https://spacelift.io/blog/kubectl-delete-pod" target="_blank" rel="noopener">kubectl delete pod</a> and kubectl delete replicaset</code>
Each pod can be deleted individually if required:
<code>kubectl delete pod &lt;pod_name&gt; -n &lt;namespace&gt;</code>
Doing this will cause the pod to be recreated because K8S is declarative, it will create a new pod based on the specified configuration.
However, where lots of pods are running this is not really a practical approach. Where lots of pods have the same label however, you could use that to select multiple pods at once:
<code>kubectl delete pod -l “app:myapp” -n &lt;namespace&gt;</code>
Another approach if there are lots of pods, then ReplicaSet can be deleted instead:
<code>kubectl delete replicaset &lt;name&gt; -n &lt;namespace&gt;</code>

<h3>Method 4</h3>
<code>kubectl get pod | kubectl replace</code>
The pod to be replaced can be retrieved using the <code>kubectl get pod</code> to get the YAML statement of the currently running pod and pass it to the <code>kubectl replace</code> command with the <code>--force</code> flag specified in order to achieve a restart. This is useful if there is no YAML file available and the pod is started.
<code>kubectl get pod &lt;pod_name&gt; -n &lt;namespace&gt; -o yaml | kubectl replace --force -f -</code>

<h3>Method 5</h3>
<code>kubectl set env</code>
Setting or changing an environment variable associated with the pod will cause it to restart to take the change. The example below sets the environment variable <code>DEPLOY_DATE</code> to the date specified, causing the pod to restart.
<code>kubectl set env deployment &lt;deployment name&gt; -n &lt;namespace&gt; DEPLOY_DATE="$(date)"</code>

<ul>
<li><a href="https://spacelift.io/blog/provision-kubernetes-cluster-terraform-spacelift" target="_blank" rel="noopener">How to Provision Kubernetes Cluster with Spacelift and Terraform</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-best-practices" target="_blank" rel="noopener">15 Kubernetes Best Practices to Follow</a></li>
<li><a href="https://spacelift.io/blog/ci-cd-tools" target="_blank" rel="noopener">Top Most Useful CI/CD Tools for DevOps</a></li>
</ul>

Having a range of commands to use in your toolbox when running into issues with pods in K8S will enable you to use the appropriate method to restart them, depending on how you have deployed the pods, the necessity for application uptime, and the speed you need the restart to happen. In general, the best approach is to use the <code>kubectl rollout restart</code> method described above as it will avoid application downtime.
A restart will not resolve the problem that caused the pods to have issues in the first place, so further investigation will be required into the root cause.
If you need more help with Kubernetes, <a href="https://spacelift.io" target="_blank" rel="noopener">Spacelift</a> helps you manage the complexities and compliance challenges of using Kubernetes. Anything that can be run via kubectl can be run within a Spacelift stack. It brings with it a GitOps flow, so your Kubernetes Deployments are synced with your Kubernetes Stacks, and pull requests show you a preview of what they&#8217;re planning to change. Find out more about <a href="https://docs.spacelift.io/vendors/kubernetes/" target="_blank" rel="noopener">how Spacelift works with Kubernetes</a>. You can check it for free by <a href="https://spacelift.io/free-trial" target="_blank" rel="noopener">creating a trial account</a> or <a href="https://spacelift.io/schedule-demo" target="_blank" rel="noopener">booking a demo with one of our engineers</a>

<ul>
<li>Automate, audit, secure, and continuously deliver your infrastructure.</li>
<li>Overcome common state management issues.</li>
<li>Harness invaluable infrastructure management features.</li>
</ul>

Kubectl Cheat Sheet - 15 Kubernetes Commands & Objects

12 Kubernetes Use Cases [Examples for 2024]

There is no kubectl restart [podname] command for use with Kubernetes. Learn different ways to achieve a pod ‘restart’ with kubectl.

how-to-restart-kubernetes-pods

How to Restart Kubernetes Pods With Kubectl

Manage the challenges of Kubernetes with a GitOps flow, policies, and the ability to communicate between stacks from your choice of IaC tools.

James Walker

<a title="Kubernetes" href="https://kubernetes.io" target="_blank" rel="nofollow noopener">Kubernetes</a> is the most popular orchestrator for deploying and scaling containerized systems. You can use Kubernetes to reliably build and distribute your applications in the cloud.
In this beginner&#8217;s guide, you&#8217;ll learn what Kubernetes can do and how to get started running your own containerized solutions.
<ol>
<li><a href="https://spacelift.io/blog/kubernetes-tutorial#what-is-kubernetes">What Is Kubernetes?</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-tutorial#kubernetes-features">Kubernetes Features</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-tutorial#how-kubernetes-works">How Kubernetes Works</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-tutorial#installation-and-setup">Installation and Setup</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-tutorial#kubernetes-basic-terms-and-concepts">Kubernetes Basic Terms and Concepts</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-tutorial#using-kubectl-to-interact-with-kubernetes">Using Kubectl to Interact With Kubernetes</a></li>
</ol>

Kubernetes is an open-source system that automates container deployment tasks. It was originally developed at Google but is now maintained as part of the <a href="https://www.cncf.io" target="_blank" rel="nofollow noopener"> Cloud Native Computing Foundation (CNCF).</a>
Kubernetes has risen to prominence because it solves many of the challenges around using containers in production. It makes it easy to launch limitless container replicas, distribute them across multiple physical hosts, and set up networking so users can reach your service.
Most developers begin their container journey with <a href="https://spacelift.io/blog/docker-tutorial" target="_blank" rel="noopener"> Docker</a>. While this is a comprehensive tool, it&#8217;s relatively low-level and relies on CLI commands that interact with one container at a time. Kubernetes provides much higher-level abstractions for defining applications and their infrastructure using declarative schemas you can collaborate on.
Check out <a href="https://spacelift.io/blog/docker-vs-kubernetes" target="_blank" rel="noopener">Docker vs. Kubernetes Comparison</a>.

Kubernetes has a comprehensive feature set that includes a full spectrum of capabilities for running containers and associated infrastructure:
<ul>
<li>Automated rollouts, scaling, and rollbacks &#8211; Kubernetes automatically creates the specified number of replicas, distributes them onto suitable hardware, and takes action to reschedule your containers if a node goes down. You can instantly scale the number of replicas on-demand or in response to changing conditions such as CPU usage.</li>
<li>Service discovery, load balancing, and network ingress &#8211; Kubernetes provides a complete networking solution that covers internal service discovery and public container exposure.</li>
<li>Stateless and stateful applications &#8211; While Kubernetes initially focused on stateless containers, it&#8217;s now also got <a href="https://kubernetes.io/docs/concepts/workloads/controllers/statefulset" target="_blank" rel="nofollow noopener"> built-in objects</a> to represent stateful apps too. You can run any kind of application in Kubernetes</li>
<li>Storage management &#8211; Persistent storage is abstracted by a consistent interface that works across providers, whether in the cloud, on a network share, or on a local filesystem.</li>
<li>Declarative state &#8211; Kubernetes uses object manifests in YAML files to define the state you want to create in your cluster. Applying a manifest instructs Kubernetes to automatically transition the cluster to the target state. You don&#8217;t have to manually script the changes you want to see.</li>
<li>Works across environments &#8211; Kubernetes can be used in the cloud, at the edge, or on your developer workstation. Many different distributions are available to match different use cases. Major cloud providers like AWS and Google Cloud offer managed Kubernetes services, while single-node distributions such as <a href="https://minikube.sigs.k8s.io/docs" target="_blank" rel="nofollow noopener">Minikube</a> and <a href="https://k3s.io" target="_blank" rel="nofollow noopener">K3s</a> are great for local use.</li>
<li>Highly extensible &#8211; Kubernetes packs in a lot of functionality, but you can add even more using extensions. You can create <a href="https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources" target="_blank" rel="nofollow noopener">custom object types</a>, controllers, and <a href="https://spacelift.io/blog/kubernetes-operator" target="_blank" rel="noopener">operators</a> to support your own workloads.</li>
</ul>
With so many features available, Kubernetes is ideal for any situation where you want to deploy containers with declarative configuration.
Check out our <a href="https://spacelift.io/blog/openshift-vs-kubernetes" target="_blank" rel="noopener">OpenShift vs. Kubernetes comparison</a>.

Kubernetes has a reputation for complexity because it has several moving parts. Understanding the basics of how they fit together will help you start out on your Kubernetes journey.
A Kubernetes environment is termed a cluster. It includes one or more nodes. A node is simply a machine that will run your containers. It could be physical hardware or a VM.
As well as nodes, the cluster also has a control plane. The control plane coordinates the entire cluster&#8217;s operations. It schedules new containers onto available nodes and provides the API server that you interact with. It&#8217;s possible to run a cluster with <a href="https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/high-availability" target="_blank" rel="nofollow noopener">multiple control plane instances</a> to create a highly available setup with greater resiliency.
Here are the most important Kubernetes components:
<ul>
<li>kube-apiserver &#8211; This is the part of the control plane that runs the API server. It&#8217;s the only way to interact with a running Kubernetes cluster. You can issue commands to the API server using the <a href="https://kubernetes.io/docs/tasks/tools" target="_blank" rel="nofollow noopener">Kubectl CLI</a> or an HTTP client.</li>
<li>kube-controller-manager &#8211; The controller manager starts and runs Kubernetes&#8217; built-in controllers. A <a href="https://kubernetes.io/docs/concepts/architecture/controller" target="_blank" rel="nofollow noopener">controller</a> is essentially an event loop that applies actions after changes in your cluster. They create, scale, and delete objects in response to events such as an API request or increased load.</li>
<li>kube-scheduler &#8211; The scheduler assigns new Pods (containers) onto the nodes in your cluster. It establishes which nodes can fulfill the Pod&#8217;s requirements, then selects the most optimal placement to maximize performance and reliability.</li>
<li>kubelet &#8211; Kubelet is a worker process that runs on each of your nodes. It maintains communication with the Kubernetes control plane to receive its instructions. Kubelet is responsible for pulling container images and starting containers in response to scheduling requests.</li>
<li>kube-proxy &#8211; Proxy is another component found on individual nodes. It configures the host&#8217;s networking system so traffic can reach the services in your cluster.</li>
</ul>
<a href="https://kubernetes.io/docs/tasks/tools" target="_blank" rel="nofollow noopener">Kubectl</a> is usually the final piece in a functioning Kubernetes environment. You&#8217;ll need this CLI to interact with your cluster and its objects. Once your cluster&#8217;s set up, you can also install the <a href="https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard" target="_blank" rel="nofollow noopener">official dashboard</a> or a third-party solution to control Kubernetes from a GUI.

<ul>
<li><a href="https://spacelift.io/blog/provision-kubernetes-cluster-terraform-spacelift" target="_blank" rel="noopener">How to Provision Kubernetes Cluster with Terraform</a></li>
<li><a href="https://spacelift.io/blog/kubernetes-best-practices" target="_blank" rel="noopener">17 Kubernetes Best Practices to Follow</a></li>
<li><a href="https://spacelift.io/blog/terraform-vs-kubernetes" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;Terraform vs. Kubernetes : Key Differences and Comparison&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">Terraform vs. Kubernetes Comparison</a></li>
</ul>

There are many different ways to get started with Kubernetes because of the range of distributions on offer. Creating a cluster <a href="https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm" target="_blank" rel="nofollow noopener">using the official distribution</a> is relatively involved so most people use a packaged solution like <a href="https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm" target="_blank" rel="nofollow noopener">Minikube</a>, <a href="https://microk8s.io" target="_blank" rel="nofollow noopener">MicroK8s</a>, <a href="https://k3s.io" target="_blank" rel="nofollow noopener">K3s</a>, or <a href="https://kind.sigs.k8s.io" target="_blank" rel="nofollow noopener">Kind</a>.
Check out <a href="https://spacelift.io/blog/install-kubernetes" target="_blank" rel="noopener">how to install Kubernetes</a> using these four different methods.
We&#8217;ll use K3s for this tutorial. It&#8217;s an ultra-lightweight Kubernetes distribution that bundles all the Kubernetes components into a single binary. Unlike other options, there&#8217;s no dependencies to install or heavy VMs to run. It also includes the Kubectl CLI that you&#8217;ll use to issue <a href="https://spacelift.io/blog/kubernetes-cheat-sheet" target="_blank" rel="noopener">Kubernetes commands</a>.
Running the following command will install K3s on your machine:

It automatically downloads the latest available Kubernetes release and registers a system service for K3s.
After installation, run the following command to copy the auto-generated Kubectl config file into your .kube directory:

Now tell K3s to use this <a href="https://spacelift.io/blog/kubeconfig" target="_blank" rel="noopener">config file</a> by running the following command:

You can add this line to your <code>~/.profile</code> or <code>~/.bashrc</code> file to automatically apply the change after you login.
Next run this command:

You should see a single node appear, named with your machine&#8217;s hostname. The node shows as Ready so your Kubernetes cluster can now be used!

Your cluster&#8217;s running, but what can you do with it? It&#8217;s worth getting familiar with some key Kubernetes terms before you continue.

<h3>Nodes</h3>
Nodes represent the physical machines that form your <a href="https://spacelift.io/blog/kubernetes-cluster" target="_blank" rel="noopener">Kubernetes cluster</a>. They run the containers you create. Kubernetes tracks the status of your nodes and exposes each one as an object. You used Kubectl to retrieve a list of nodes in the example above.
While your fresh cluster has only one node, Kubernetes advertises support for <a href="https://kubernetes.io/docs/setup/best-practices/cluster-large" target="_blank" rel="nofollow noopener">up to 5,000 nodes</a>. It&#8217;s theoretically possible to <a href="https://openai.com/blog/scaling-kubernetes-to-7500-nodes" target="_blank" rel="noopener">scale even further</a>.
<h3>Namespaces</h3>
<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces" target="_blank" rel="nofollow noopener">Namespaces</a> isolate different groups of resources. They avoid name collisions by scoping the visibility of your resources.
Creating two objects with the same name is forbidden within the same namespace. If you&#8217;re in the default namespace, you can&#8217;t create two Pods that are both called database, for example. Namespaces resolve this by providing logical separation of resources. Two namespaces called app-1 and app-2 could each contain a Pod called database without causing a conflict.
Namespaces are flexible and can be used in many different ways. It&#8217;s a good idea to create a namespace for each workload in your cluster. You can also use namespaces to divide resources between users and teams by applying <a href="https://kubernetes.io/docs/reference/access-authn-authz/rbac" target="_blank" rel="nofollow noopener">role-based access control</a>.
<h3>Pods</h3>
<a href="https://kubernetes.io/docs/concepts/workloads/pods" target="_blank" rel="nofollow noopener">Pods</a> are the fundamental compute unit in Kubernetes. A Pod is analogous to a container but with some key differences. Pods can contain multiple containers, each of which share a context. The entire Pod will always be scheduled onto the same node. The containers within a Pod are tightly coupled so you should create a new Pod for each distinct part of your application, such as its API and database.
In simple situations, Pods will usually map one-to-one with the containers your application runs. In more advanced cases, Pods can be enhanced with <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers" target="_blank" rel="nofollow noopener">init containers</a> and <a href="https://kubernetes.io/docs/concepts/workloads/pods/ephemeral-containers" target="_blank" rel="nofollow noopener">ephemeral containers</a> to customize startup behavior and provide detailed debugging.
<h3>ReplicaSets</h3>
<a href="https://kubernetes.io/docs/concepts/workloads/controllers/replicaset" target="_blank" rel="nofollow noopener">ReplicaSets</a> are used to consistently replicate a Pod. They provide a guarantee that a set number of replicas will be running at any time. If a node goes offline or a Pod becomes unhealthy, Kubernetes will automatically schedule a new Pod instance to maintain the specified replica count.
<h3>Deployments</h3>
<a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment" target="_blank" rel="nofollow noopener">Deployments</a> wrap ReplicaSets with support for declarative updates and rollbacks. They&#8217;re a higher level of abstraction that&#8217;s easier to control.
A Deployment object lets you specify the desired state of a set of Pods. This includes the number of replicas to run. Modifying the Deployment will automatically detect the required changes and scale the ReplicaSet as required. You can <a href="https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#pausing-and-resuming-a-deployment" target="_blank" rel="nofollow noopener">pause the rollout</a> or revert to an earlier revision, features that aren&#8217;t available with plain ReplicaSets.
Learn <a href="https://spacelift.io/blog/kubernetes-deployment-yaml" target="_blank" rel="noopener">how to create a Kubernetes Deployment YAML file</a>.
<h3>Services</h3>
<a href="https://spacelift.io/blog/kubernetes-service" target="_blank" rel="noopener">Kubernetes Services</a> are used to expose Pods to the network. They allow defined access to Pods either within your cluster or externally.
<a href="https://kubernetes.io/docs/concepts/services-networking/ingress" target="_blank" rel="nofollow noopener">Ingresses</a> are closely related objects. These are used to set up HTTP routes to services via a <a href="https://spacelift.io/blog/kubernetes-load-balancer" target="_blank" rel="noopener">load balancer</a>. Ingresses also support HTTPS traffic secured by TLS certificates.
Read more: <a href="https://spacelift.io/blog/kubernetes-ingress">Kubernetes Ingress with NGINX Ingress Controller Example</a>
<h3>Jobs</h3>
A <a href="https://spacelift.io/blog/kubernetes-jobs" target="_blank" rel="noopener">Kubernetes Job</a> is an object that creates a set of Pods and waits for them to terminate. It will retry any failed Pods until a specified number have exited successfully. The Job&#8217;s then marked as complete.
Jobs provide a mechanism for running ad-hoc tasks inside your cluster. Kubernetes also provides <a href="https://spacelift.io/blog/kubernetes-cronjob" target="_blank" rel="noopener">CronJobs</a> that wrap Jobs with <a href="https://en.wikipedia.org/wiki/Cron" target="_blank" rel="nofollow noopener">cron-like</a> scheduling support. These let you automatically run a job on a regular cadence to accommodate batch activities, backups, and any other scheduled tasks your application requires.
<h3>Volumes</h3>
<a href="https://kubernetes.io/docs/concepts/storage/volumes" target="_blank" rel="nofollow noopener">Volumes</a> mount external filesystem storage inside your Pods. They abstract away the differences between different cloud providers&#8217; storage implementations.
Volumes can and shared between your Pods. This allows Kubernetes to run stateful applications where data must be preserved after a Pod gets terminated or rescheduled. You&#8217;ll need to use a volume whenever you&#8217;re running a database or file server in your cluster.
<h3>Secrets and ConfigMaps</h3>
<a href="https://spacelift.io/blog/kubernetes-secrets" target="_blank" rel="noopener">Secrets</a> are used to inject sensitive data into your cluster such as API keys, certificates, and other kinds of credential. They can be supplied to Pods as environment variables or files mounted into a volume.
<a href="https://spacelift.io/blog/kubernetes-configmap" target="_blank" rel="noopener">ConfigMaps</a> are a similar concept for non-sensitive information. These objects should store any general settings your app requires.
<h3>DaemonSets</h3>
<a href="https://spacelift.io/blog/kubernetes-daemonset" target="_blank" rel="noopener">Kubernetes DaemonSets</a> are used to reliably run a copy of a Pod on each of the Nodes in your cluster. When a new Node joins, it will automatically start an instance of the Pod. You can optionally <a href="https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/#running-pods-on-select-nodes" target="_blank" rel="nofollow noopener">restrict DaemonSet Pods</a> to only running on specific Nodes in more advanced situations.
DaemonSets are useful when you’re adding global functionality to your cluster. DaemonSets are often used to run monitoring services and log aggregation agents. Placing these workloads into a DaemonSet guarantees they’ll always be running adjacent to your application’s Pods. It ensures metrics and logs will be collected irrespective of the Node a Pod gets scheduled to.
<h3>Networking Policies</h3>
<a href="https://spacelift.io/blog/kubernetes-network-policy" target="_blank" rel="noopener">Kub</a>ernetes supports a <a href="https://spacelift.io/blog/kubernetes-network-policy" target="_blank" rel="noopener">policy-based system for controlling network traffic flows</a> between your Pods. You can isolate sensitive Pods from other resources to prevent attackers moving through your infrastructure.
Network policies are expressed as an object that targets one or more matching Pods. Each Pod can be the subject of both ingress and egress policies. Ingress policies define whether incoming traffic is allowed, while egress rules affect outbound flows. Communications between two Pods are only permitted when no networking policy on either Pod denies ingress or egress from the other.
Learn more: <a href="https://spacelift.io/blog/kubernetes-architecture" target="_blank" rel="noopener">What Is Kubernetes Architecture?</a>

Now you&#8217;re familiar with the basics, you can start adding workloads to your cluster with Kubectl. Here&#8217;s a quick reference for some key commands.
<h3>List Pods</h3>
This displays the Pods in your cluster:

Specify a namespace with the <code>-n</code> or <code>--namespace</code> flag:

Alternatively, get Pods from all your namespaces by specifying <code>--all-namespaces</code>:

This includes Kubernetes system components.

<h3>Create a Pod</h3>
Create a Pod with the following command:

This starts a Pod called nginx that will run the nginx:latest container image.

<h3>Create a Deployment</h3>
Creating a Deployment lets you scale multiple replicas of a container:

You&#8217;ll see three Pods are created, each running the nginx:latest image:

<h3>Scale a Deployment</h3>
Now use this command to increase the replica count:

Kubernetes has created two extra Pods to provide additional capacity:

<h3>Expose a Service</h3>
Now let&#8217;s make this NGINX server accessible.
Run the following command to create a service that&#8217;s exposed on a port of the Node running the Pods:

Discover the port that&#8217;s been assigned by running this command:

The port is 30226. Visiting &lt;node-ip&gt;:30226 in your browser will show the default NGINX landing page.
You can use localhost as &lt;node-ip&gt; if you&#8217;ve been following along with the single-node K3s cluster created in this tutorial. Otherwise <a href="https://spacelift.io/blog/kubectl-get-nodes" target="_blank" rel="noopener">run the get nodes command</a> and use the INTERNAL-IP that&#8217;s displayed.

<h3>Using Port Forwarding</h3>
You can access a service without binding it to a Node port by using <a href="https://spacelift.io/blog/kubectl-port-forward" target="_blank" rel="noopener">Kubectl’s integrated port-forwarding functionality</a>. Delete your first service and create a new one without the <code>--type</code> flag:

This creates a ClusterIP service that can be accessed on an internal IP, within the cluster.
Retrieve the service’s details by running this command:

The service can be accessed inside the cluster at 10.100.191.238:80.
You can reach this address from your local machine with the following command:

Visiting localhost:8080 in your browser will display the NGINX landing page. Kubectl is redirecting traffic to the service inside your cluster. You can press Ctrl+C in your terminal to stop the port forwarding session when you’re done.
Port forwarding works without services too. You can directly connect to a Pod in your deployment with this command:

Visiting localhost:8080 will again display the NGINX landing page, this time without going through a service.

<h3>Apply a YAML File</h3>
Finally, let&#8217;s see how to apply a declarative YAML file to your cluster. First, write a <a href="https://spacelift.io/blog/kubernetes-manifest-file" target="_blank" rel="noopener">simple Kubernetes manifest</a> for your Pod:

Save this manifest to nginx.yaml and run <code>kubectl apply</code> to automatically create your Pod:

You can repeat the command after you modify the file to apply any changes to your cluster.
Now you&#8217;re familiar with the basics of using Kubectl to interact with Kubernetes!
Anything that can be run via kubectl can be run within a Spacelift stack. <a href="https://spacelift.io" target="_blank" rel="noopener">Spacelift</a> helps you manage the complexities and compliance challenges of using Kubernetes. It brings with it a GitOps flow, so your Kubernetes Deployments are synced with your Kubernetes Stacks, and pull requests show you a preview of what they’re planning to change. It also has an extensive selection of <a href="https://docs.spacelift.io/concepts/policy/" target="_blank" rel="noopener">policies</a>, which lets you <a href="https://docs.spacelift.io/concepts/policy/terraform-plan-policy" target="_blank" rel="noopener">automate compliance checks</a> and <a href="https://docs.spacelift.io/concepts/policy/trigger-policy" target="_blank" rel="noopener">build complex multi-stack workflows</a>. Find out more about <a href="https://docs.spacelift.io/vendors/kubernetes/" target="_blank" rel="noopener">how Spacelift works with Kubernetes</a>.

Kubernetes is the leading container orchestrator. In this article, we&#8217;ve explored its features, looked at how it works, and covered the most important object types you&#8217;ll use to assemble your applications. You can also check out <a href="https://spacelift.io/blog/kubernetes-challenges" target="_blank" rel="noopener">15 challenges and pitfalls to look for each time you use Kubernetes</a> and take a look at the guide to <a href="https://spacelift.io/blog/kubernetes-certification" target="_blank" rel="noopener">Kubernetes certification</a>.
Beyond the theory, you&#8217;ve also seen how to start your own Kubernetes cluster with the popular K3s distribution. Now you can build and run your own containerized systems at scale with minimal manual configuration. You&#8217;re ready to continue your Kubernetes adventure by moving to more advanced topics &#8211; look out for future posts on our <a href="https://spacelift.io/blog/kubernetes">blog</a>!

Spacelift is an alternative to using homegrown solutions on top of a generic CI. It helps overcome common state management issues and adds several must-have capabilities s for infrastructure management.

8 Different Types of Kubernetes Deployment Strategies

In this beginners Kubernetes tutorial, you'll learn what Kubernetes can do and how to get started running your own containerized solutions.

kubernetes-tutorial-2

kubernetes-tutorial

In this article, we explore the Ingress object in Kubernetes (K8S), and look at how it can be used with some examples. We will then walk step-by-step through setting up an NGINX Ingress controller with Azure Kubernetes Service (AKS).

Ingress in K8S is an object that allows access to services within your <a href="https://spacelift.io/blog/kubernetes-cluster" target="_blank" rel="noopener">cluster</a>, from outside your cluster.
The official documentation on kubernetes.io describes Ingress:
<blockquote class="mo mp mq">
An API object that manages external access to the services in a cluster, typically HTTP. Ingress may provide load balancing, SSL termination and name-based virtual hosting.
</blockquote>
Traffic routing is defined by rules specified on the Ingress resource.
Ingress objects refer to allowing HTTP or HTTPS traffic through to your cluster services. They do not expose other ports or protocols to the wider world. For this, a service type of LoadBalancer or NodePort should be used.
A service is an external interface to a logical set of Pods. Services use a &#8216;virtual IP address&#8217; local to the cluster, external services would have no way to access these IP addresses without an Ingress.

Ingress, LoadBalancer, and NodePort are all ways of exposing services within your K8S cluster for external consumption.
NodePort and LoadBalancer let you expose a service by specifying that value in the service’s type.
With a NodePort, K8S allocates a specific port on each node to the service specified. Any request received on the port by the cluster simply gets forwarded to the service.
With a LoadBalancer, there needs to be an external service outside of the K8S cluster to provide the public IP address. In Azure, this would be an Azure Application Gateway in front of your Azure Kubernetes Service (AKS) cluster. In AWS, this would be an Application Load Balancer (ALB) in front of your Elastic Kubernetes Service (EKS), and in Google cloud, this would be a Network Load Balancer in front of your Google Kubernetes Engine (GKE) cluster.
Each time a new service is exposed, a new LoadBalancer needs to be created to get a public IP address. Conveniently, the Load balancer provisioning happens automatically for you because of the way the Cloud providers plugin to Kubernetes, so that doesn’t have to be done separately.
Ingress is a completely independent resource to your service. As well as enabling routing rules to be consolidated in one place (the Ingress object), this has the advantage of being a separate, decoupled entity that can be created and destroyed separately from any services.

To set up Ingress in K8S, you need to configure an Ingress controller. These do not come as default with the cluster and must be installed separately. An ingress controller is typically a reverse web proxy server implementation in the cluster.
There are many available Ingress controllers, all of which have different features. The official documentation lists the available Ingress controllers. A few commonly used ones include:
<ul class="">
<li id="46c2" class="mv mw in ke b kf kg ki kj kl mx kp my kt mz kx na nb nc nd gr" data-selectable-paragraph=""><a class="au ln" href="https://docs.microsoft.com/azure/application-gateway/tutorial-ingress-controller-add-on-existing?toc=https%3A%2F%2Fdocs.microsoft.com%2Fen-us%2Fazure%2Faks%2Ftoc.json&amp;bc=https%3A%2F%2Fdocs.microsoft.com%2Fen-us%2Fazure%2Fbread%2Ftoc.json" target="_blank" rel="noopener ugc nofollow">AKS Application Gateway Ingress Controller</a> is an ingress controller that configures the <a class="au ln" href="https://docs.microsoft.com/azure/application-gateway/overview" target="_blank" rel="noopener ugc nofollow">Azure Application Gateway</a>.</li>
<li id="655b" class="mv mw in ke b kf ne ki nf kl ng kp nh kt ni kx na nb nc nd gr" data-selectable-paragraph=""><a class="au ln" href="https://github.com/kubernetes/ingress-gce" target="_blank" rel="noopener ugc nofollow">GKE Ingress Controller for Google Cloud</a></li>
<li id="7621" class="mv mw in ke b kf ne ki nf kl ng kp nh kt ni kx na nb nc nd gr" data-selectable-paragraph=""><a class="au ln" href="https://docs.aws.amazon.com/eks/latest/userguide/alb-ingress.html" target="_blank" rel="noopener ugc nofollow">AWS Application Load Balancer Ingress Controller</a></li>
<li id="2e85" class="mv mw in ke b kf ne ki nf kl ng kp nh kt ni kx na nb nc nd gr" data-selectable-paragraph=""><a class="au ln" href="https://haproxy-ingress.github.io/" target="_blank" rel="noopener ugc nofollow">HAProxy Ingress</a> is an ingress controller for <a class="au ln" href="https://www.haproxy.org/#desc" target="_blank" rel="noopener ugc nofollow">HAProxy</a>.</li>
<li id="ad9c" class="mv mw in ke b kf ne ki nf kl ng kp nh kt ni kx na nb nc nd gr" data-selectable-paragraph=""><a class="au ln" href="https://istio.io/latest/docs/tasks/traffic-management/ingress/kubernetes-ingress/" target="_blank" rel="noopener ugc nofollow">Istio Ingress</a> is an <a class="au ln" href="https://istio.io/" target="_blank" rel="noopener ugc nofollow">Istio</a> based ingress controller.</li>
<li id="e30a" class="mv mw in ke b kf ne ki nf kl ng kp nh kt ni kx na nb nc nd gr" data-selectable-paragraph="">The <a class="au ln" href="https://www.nginx.com/products/nginx-ingress-controller/" target="_blank" rel="noopener ugc nofollow">NGINX Ingress Controller for Kubernetes</a> works with the <a class="au ln" href="https://www.nginx.com/resources/glossary/nginx/" target="_blank" rel="noopener ugc nofollow">NGINX</a> webserver (as a proxy).</li>
<li id="3162" class="mv mw in ke b kf ne ki nf kl ng kp nh kt ni kx na nb nc nd gr" data-selectable-paragraph="">The <a class="au ln" href="https://doc.traefik.io/traefik/providers/kubernetes-ingress/" target="_blank" rel="noopener ugc nofollow">Traefik Kubernetes Ingress provider</a> is an ingress controller for the <a class="au ln" href="https://traefik.io/traefik/" target="_blank" rel="noopener ugc nofollow">Traefik</a> proxy.</li>
</ul>
You can have multiple ingress controllers in a cluster mapped to multiple load balancers should you wish!
Learnk8s has a fantastic feature <a class="au ln" href="https://docs.google.com/spreadsheets/d/191WWNpjJ2za6-nbG4ZoUMXMpUK8KlCIosvQB0f-oq3k/edit#gid=907731238" target="_blank" rel="noopener ugc nofollow">comparison of all the available ingress controllers</a> to help you make your choice. Note the limitations of the Azure application gateway ingress controller. For now, the NGINX Ingress Controller seems like a better choice…

<ul>
<li><a href="https://spacelift.io/blog/terraform-vs-kubernetes"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;What is difference between Terraform and Kubernetes?\r&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">What is the difference between Terraform and Kubernetes?</a></li>
<li><a href="https://spacelift.io/blog/how-specialized-solution-can-improve-your-iac"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;10 Ways to Improve Your Infrastructure as Code&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">10 Ways to Improve Your Infrastructure as Code</a></li>
<li><a href="https://spacelift.io/blog/ci-cd-tools" target="_blank" rel="noopener">Top Most Useful CI/CD Tools for DevOps</a></li>
</ul>

NGINX is a widely used Ingress controller, we will run through how to set this up with Azure Kubernetes Service. We will set up two simple web services and use the NGINX Ingress to route the traffic accordingly.
<h3>Step 1 &#8211; Fire up your AKS cluster and connect to it</h3>
To do this, browse to the AKS cluster resource in the Azure Portal and click on connect. The commands needed to connect via your shell using the Azure CLI will be shown.
<h3>Step 2 &#8211; Install the NGINX Ingress controller</h3>
It will install the controller in the <code class="gq og oh oi oj b">ingress-nginx</code> namespace, creating that namespace if it doesn&#8217;t already exist.

Keep all of your kubectl commands in one place with our <a href="https://spacelift.io/blog/kubernetes-cheat-sheet" target="_blank" rel="noopener">Kubernetes Cheat Sheet</a>.

kubernetes-ingress-install-nginx

kubernetes ingress - install nginx

Note you can also use Helm to install if you have it installed (you don’t need to run this if you have already installed using the previous command):

<h3>Step 3 &#8211; Check the Ingress controller pod is running</h3>

kubernetes-ingress-checking-nginx

kubernetes ingress - checking nginx

<h3>Step 4 &#8211; Check the NGINX Ingress controller has been assigned a public Ip address</h3>

Note the service type is LoadBalancer:

kubernetes-ingress-loadbalancer

kubernetes ingress - loadbalancer

Browsing to this IP address will show you the NGINX 404 page. This is because we have not set up any routing rules for our services yet.

kubernetes-ingress-nginx-404

kubernetes ingress - nginx 404

<h3>Step 5 &#8211; Set up a basic web app for testing our new Ingress controller</h3>
First, we need to set up a DNS record pointing to the External IP address we discovered in the previous step. Once that is set, run the following command to set up a demo (replace the [DNS_NAME] with your record, e.g. www.jackwesleyroper.io).
Note that you must set up a DNS record, this step will not work with an IP address. This command comes from the NGINX documentation, we will look at declarative approaches later in this article.

<h3 id="7a30" class="pw-post-body-paragraph kc kd in ke b kf kg jo kh ki kj jr kk kl km kn ko kp kq kr ks kt ku kv kw kx ig gr">Step 6 &#8211; Browse to the web address</h3>
You will see ‘It works!’ displayed, confirming that the Ingress controller is correctly routing traffic to the demo app.
<h3 id="1eea" class="pw-post-body-paragraph kc kd in ke b kf kg jo kh ki kj jr kk kl km kn ko kp kq kr ks kt ku kv kw kx ig gr">Step 7 &#8211; Set up two more web apps</h3>
Now we will set up two more web apps, and route traffic between them using NGINX.
We will create two YAML files using the demo apps from the official Azure documentation.
aks-helloworld-one.yaml

aks-helloworld-two.yaml

Apply the two configuration files to setup the apps:

kubernetes-ingress-configuration-file-one

kubernetes ingress - configuration file one

kubernetes-ingress-configuration-file-two

kubernetes ingress - configuration file two

Check the new pods are running (you should see two <code>aks-helloworld</code> pods running):

kubernetes-ingress-kubectl-get-pods

kubernetes ingress - kubectl get pods

<h3 id="8348" class="pw-post-body-paragraph kc kd in ke b kf kg jo kh ki kj jr kk kl km kn ko kp kq kr ks kt ku kv kw kx ig gr">Step 8 &#8211; Setup the Ingress to route traffic between the two apps</h3>
We will set up path-based routing to direct traffic to the appropriate web apps based on the URL the user enters. EXTERNAL_IP/hello-world-one is routed to the service named <code class="gq og oh oi oj b">aks-helloworld-one</code>. Traffic to EXTERNAL_IP/hello-world-two is routed to the <code class="gq og oh oi oj b">aks-helloworld-two</code> service. Where the path is not specified by the user (EXTERNAL_IP/), the traffic is routed to <code class="gq og oh oi oj b">aks-helloworld-one</code>.
Create a file named hello-world-ingress.yaml.

kubernetes-ingress-ingress

kubernetes ingress - ingress

<h3>Step 9 &#8211; Browse to the EXTERNAL_IP/hello-world-one</h3>

kubernetes-ingress-welcome-one

kubernetes ingress - welcome one

And EXTERNAL_IP/hello-world-two:

kubernetes-ingress-welcome-two

kubernetes ingress - welcome two

An Ingress in K8S is a robust way to expose services within your K8S cluster to the outside world. It allows you to consolidate routing rules in one place. There are many available Ingress controllers available for use, in this article, we configured an NGINX Ingress on AKS and used it to route traffic between two demo apps.
For more information on Kubernetes Ingress, check out the <a href="https://kubernetes.io/docs/concepts/services-networking/ingress/" target="_blank" rel="nofollow noopener">Kubernetes documentation</a>, <a href="https://kubernetes.github.io/ingress-nginx/deploy/" target="_blank" rel="nofollow noopener">Kubernetes GitHub</a> and <a href="https://docs.microsoft.com/en-us/azure/aks/ingress-basic?tabs=azure-cli#create-an-ingress-controller" target="_blank" rel="nofollow noopener">AKS documentation</a>.
And if you want to learn how Spacelift can help you with Kubernetes management, see <a href="https://docs.spacelift.io/vendors/kubernetes/" target="_blank" rel="noopener">Spacelift documentation</a>. Anything that can be run via kubectl can be run within a Spacelift stack.

Managing Azure Resources using Spacelift

How to Provision Azure AKS Cluster Using Terraform

Explore the Kubernetes Ingress object and see a step-by-step tutorial on how to configure an NGINX Ingress on AKS.

107-kubernetes-ingress

Kubernetes Ingress & Examples

Kubernetes Ingress with NGINX Ingress Controller Example

Enable Auto-completion for Kubectl in a Linux Bash Shell

Flavius Dinu

In this post, we will demonstrate how to install kubectl, set up auto-completion, and set an alias for kubectl in your Linux Bash Shell, Zsh, and PowerShell.
What we will cover:
<ol>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#what-is-kubectl-autocomplete-">What is kubectl autocomplete?</a></li>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#benefits-of-using-kubectl-autocomplete">Benefits of using kubectl autocomplete</a></li>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#how-to-set-up-kubectl-autocomplete-in-a-linux-bash-shell">How to set up kubectl autocomplete in a Linux Bash Shell</a></li>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#how-to-set-up-kubectl-autocomplete-in-mac-zsh">How to set up kubectl autocomplete in Mac Zsh</a></li>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#how-to-set-up-kubectl-autocomplete-in-powershell">How to set up kubectl autocomplete in PowerShell</a></li>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#kubectl-autocomplete-in-action--examples">Kubectl autocomplete in action &#8211; example</a></li>
<li><a href="https://spacelift.io/blog/kubectl-auto-completion#why-is-kubectl-autocomplete-not-working">Why is kubectl autocomplete not working?</a></li>
</ol>

Kubectl autocompletion is a feature that lets you set up an alias for kubectl on the command line (commonly as <code class="gr kj kk kl km b">k</code> ). Auto-completion can be very useful to avoid having to reference a cheat sheet constantly when using kubectl commands to interact with your <a href="https://spacelift.io/blog/kubernetes-cluster" target="_blank" rel="noopener">Kubernetes cluster</a>. It also helps save a lot of time when managing your cluster, and is recommended for the CKA administrator exam as it is very time limited.

There are many benefits to using any autocomplete tool, but when it comes to Kubernetes, this is even more helpful, as kubectl commands can take a very long time. Let’s explore some of the benefits:
<ul>
<li style="font-weight: 400;" aria-level="1">Efficiency – reduce the amount of typing required, especially in very long commands</li>
</ul>
<ul>
<li aria-level="1">Minimize errors – by suggesting command completions, you minimize the chances for mistyping, thus reducing overall frustration</li>
</ul>
<ul>
<li aria-level="1">Enhanced learning – this is beneficial, especially for people just starting out with K8s, as auto-completion can serve as an education tool by showing available commands and options users may not be familiar with</li>
</ul>
<ul>
<li aria-level="1">Increased productivity – streamline workflows by allowing users to execute commands more quickly and accurately</li>
</ul>

First, let&#8217;s set up kubectl autocomplete for a Linux Bash Shell
<h3>1) Install Kubectl on Linux</h3>
Open your bash shell. Type <code class="gr kj kk kl km b">kubectl</code>. If you see the message ‘kubectl: command not found’, follow these steps to install <code class="gr kj kk kl km b">kubectl</code>. If it is installed, skip to 2) Set up Auto-completion.

kubectl-autocompletion

kubectl autocompletion

Download the latest <code class="gr kj kk kl km b">kubectl</code> release with the command:

Validate the kubectl binary against the checksum file:

Type <code class="gr kj kk kl km b">kubectl</code> . You should now see the tool is installed.

kubectl-autocompletion-installation

kubectl autocompletion - installation

<h3>2) Set up Auto-completion</h3>
Check if <code class="gr kj kk kl km b">bash-completion</code> is already installed:

If it is already installed, you will see something like the following:

kubectl-autocompletion-bash-completion

kubectl autocompletion - bash-completion

If it is not installed, install using apt or yum, depending on which package manager you are using (usually apt for Ubuntu):

Set the kubectl completion script source for your shell sessions:
For all users on the system:

Reload your bash shell. Type <code class="gr kj kk kl km b">kubectl -</code> followed by pressing tab twice to see the available options and verify auto-complete is working:

kubectl-autocompletion-reload-your-bash-shell

kubectl autocompletion - Reload your bash shell

<h3>3) Set up an alias for kubectl and enable auto-completion</h3>
Set an alias for kubectl as <code class="gr kj kk kl km b">k</code>.

Enable the alias for auto-completion.

Reload your bash shell. Type <code class="gr kj kk kl km b">k -</code> followed by pressing tab twice to see the available options and verify auto-complete is working with the alias.

kubectl-autocompletion-reload-your-bash-shell-again

kubectl autocompletion - Reload your bash shell again

<ul>
<li><a href="https://spacelift.io/blog/terraform-vs-kubernetes" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;What is the difference between Terraform and Kubernetes?&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">What is the difference between Terraform and Kubernetes?</a></li>
<li><a href="https://spacelift.io/blog/how-specialized-solution-can-improve-your-iac" target="_blank" rel="noopener"><span data-sheets-value="{&quot;1&quot;:2,&quot;2&quot;:&quot;10 Ways to Improve Your Infrastructure as Code&quot;}" data-sheets-userformat="{&quot;2&quot;:513,&quot;3&quot;:{&quot;1&quot;:0},&quot;12&quot;:0}">10 Ways to Improve Your Infrastructure as Code</a></li>
<li><a href="https://spacelift.io/blog/ci-cd-tools" target="_blank" rel="noopener">Top Most Useful CI/CD Tools for DevOps</a></li>
</ul>

To setup kubectl autocomplete, you will need to initially run the following commands:

Then, you should edit your zsh profile (~/.zshrc) and add the kubectl autocomplete inside the plugins:

To set up kubectl autocomplete in Windows, you just need to run:

To use the kubectl autocomplete, you just need to start typing a command you want to use, and by pressing tab, you will get suggestions for how to autocomplete.

kubectl-autocomplete-example

kubectl autocomplete example

There are several reasons why kubectl autocomplete may not be working:
<ol>
<li aria-level="1">Shell Compatibility – kubectl autocomplete is supported in zsh, bash, and powershell.</li>
<li aria-level="1">Installation Path – you should ensure that your kubectl executable is accessible in the system PATH.</li>
<li aria-level="1">Shell aliases – if you are using an alias for kubectl, you might need to also set up autocompletion for that alias.</li>
<li aria-level="1">Profile not sourced – if you’ve just changed your profile, you need to source it or restart the terminal to ensure autocompletion is working properly.</li>
<li aria-level="1">Incomplete installation – sometimes autocompletion dependencies may be a part of a different package, so depending on how you’ve installed kubectl, you may need to install something else.</li>
</ol>

Enabling auto-completion for <code class="gr kj kk kl km b">kubectl</code> and setting an alias will save you time!
Additionally, Spacelift can help you manage the complexities and compliance challenges of using Kubernetes. Anything that can be run via kubectl can be run within a Spacelift stack. Read about <a href="https://docs.spacelift.io/vendors/kubernetes/" target="_blank" rel="noopener">how Spacelift works with Kubernetes</a>. If you want to learn more, <a href="https://spacelift.io/free-trial" target="_blank" rel="noopener">create a free account today</a> or <a href="https://spacelift.io/schedule-demo" target="_blank" rel="noopener">book a demo with one of our engineers</a>.
Cheers!

Spacelift allows you to automate, audit, secure, and continuously deliver your infrastructure.  It helps overcome common state management issues and adds several must-have features for infrastructure management.

In this step-by-step tutorial, you’ll learn how to enable kubectl autocomplete for Linux Bash, Zsh, and PowerShell.

Kubectl Apply vs. Kubectl Create – What’s the Difference?

Get the newsletter

Recent posts

How to Restart Kubernetes Pods With Kubectl

Kubernetes Tutorial for Beginners: Basic Concepts

Kubernetes Ingress with NGINX Ingress Controller Example

Enable Auto-Completion for Kubectl [Bash, Zsh, PowerShell]

Terraform vs. Kubernetes : Key Differences and Comparison

Kubectl Cheat Sheet – 15 Kubernetes Commands & Objects

8 Different Types of Kubernetes Deployment Strategies

What Is a Kubernetes Cluster? Key Components Explained

17 Kubernetes Best Practices Every Developer Should Know

Provision a Kubernetes Cluster with Spacelift and Terraform

Initial Availability of Kubernetes Integration in Spacelift

Running Spacelift CI/CD workers in Kubernetes using DinD

Provisioning AWS EKS Cluster with Terraform – Tutorial