Introduction to Kubernetes Imperative Commands

Introduction

Kubernetes was born out of the need to make our complex applications highly available, scalable, portable and deployable in small microservices independently. It also extends its capabilities to make adoption of DevOps processes and helps you set up modern Incident Response strategies to enhance the reliability of your applications.

Running applications in Kubernetes

Despite its complex internal architecture and API flows, Kubernetes makes it easy for users to do things with objects like deployments, services, ConfigMaps and secrets, since Kubernetes is designed to abstract away many of the complexities of managing these objects. As a result, users can focus on running their applications without having to worry about the internal details of Kubernetes.

Let’s explore how users can interact with Kubernetes.

Kubectl

Kubectl is like a Swiss Army knife of container orchestration, deployments and management. It is a powerful command line tool that can be used to manage Kubernetes deployments and resources. With it, you can inspect Kubernetes objects, view logs and perform other operational tasks. Kubectl is so powerful that every action in Kubernetes can be controlled via kubectl commands.

Imperative and Declarative methods

There are two main ways to manage Kubernetes objects: imperative (with kubectl commands) and declarative (by writing manifests and then using kubectl apply). Each has its own advantages and disadvantages, so it’s best to choose one method based on your use case.

Imperative commands are great for learning and interactive experiments, but they don’t give you full access to the Kubernetes API. They’re more commonly used to create YAML manifests and objects on the go. Declarative commands are useful for reproducible deployments and production. They’re commonly used in CI/CD pipelines and Helm charts, where YAML manifests need to be present beforehand.

Pros and Cons

Each type of command has pros and cons, so it’s important to decide which one will work best for your needs. Here’s a brief overview of the pros and cons of each method.

Deep Dive Into Imperative Commands

In this section, we will see how to use kubectl imperative commands to interact with Kubernetes clusters and do various operations on Kubernetes objects. This can be useful for managing Kubernetes clusters and developing applications.

Create

The kubectl CLI is commonly used to create objects. In order to create an object, kubectl’s imperative commands require the user to explicitly specify the type of object they wish to create, along with the properties they wish to associate with the object being created.

Since some Kubernetes objects have several subtypes, a user is required to specify the subtype-of-object parameter as well. For example, a Kubernetes service has several subtypes like ClusterIP, NodePort or LoadBalancer. A user is required to specify the service type as a subtype-of-object parameter when creating a service.

• The syntax for creating a ‘nodeport’ service is pretty simple and can be summarized as follows:

• An example of the above syntax:

Another example of where you would be required to specify a subtype-of-object parameter is when you’re creating a secret. A secret inside Kubernetes can be of the generic, TLS or Docker-registry type.

• The syntax for creating a generic secret is pretty straightforward:

• An example of the above syntax:

Examples

It can be helpful to become more familiar with the imperative commands related to the creation, so let’s take a look at some additional syntaxes along with examples.

• Example: Create a config map with a ‘name=squadcast’ key-value pair.

• Example: Create a deployment with the name Squadcast running three replicas of Ubuntu.

• Example: Create a job with the name Squadcast executing the sleep command on Ubuntu.

In addition to ‘create’, there are other functions that can help you work with Kubernetes, like ‘expose’ and ‘run’. Let’s take a look at them, too.

Expose

A service object is how a user interacts with an application in Kubernetes, and how different microservices communicate with each other. In other words, for any application to be usable on Kubernetes, it requires a service object.

The kubectl CLI is commonly used to expose applications by creating services. In order to expose an application — for example, deployments in most cases — kubectl’s imperative commands require the user to explicitly specify the name of the deployment that they wish to expose, along with port numbers that they wish to expose on the deployment object.

• To expose port 80 for your deployment, use the following syntax:

• An example of the above syntax:

Run

A pod is the smallest unit of a containerized application that can be managed by Kubernetes. You usually create pods using deployment objects, but there are many use cases where you have to create a pod independently. In fact, creating a Kubernetes pod independently is a great way to get started with managing your own containerized applications. By understanding how to create and manage pods on your own, you’ll be well on your way to becoming a Kubernetes expert.

Kubectl’s CLI is commonly used to create pods. To create a pod, kubectl’s imperative commands require the user to explicitly specify the image that would be running in the pod.

• The syntax for running pod running ‘ubuntu’ is as follows:

• An example of the above syntax:

Apart from the commands discussed above, there are some important parameters that can help you work faster with Imperative commands and Kubernetes in general. Let’s take a look at them.

Explain

Kubernetes has a lot of commands, which makes it impossible for the user to memorize everything. Though everything is available on the documentation, going over the documentation, again and again, is not efficient and could seriously slow you down. Kubectl gives an elegant solution to this in the form of ‘explain’. You can think of ‘explain’ as mini documentation that is accessible through the CLI.

‘Explain’ provides a list of parameters that a command supports, along with the use case of the commands with examples. Most importantly, it can provide you with a full-fledged YAML containing all the parameters that the object supports. Let’s take a close look.

• Examples to see parameters and description of a command:

• Examples to see a full-fledged YAML of a command:

Imperative to Declarative

If you’re working with declarative commands, you’ll need a YAML manifest. However, if you use imperative commands, you can generate these files without actually creating the objects. For example, if you use the `-dry-run=client -o yaml” flag with an imperative command like kubectl, you’ll get a YAML version of the operation (like creating objects) that you’re trying to do without actually applying the changes on the cluster. This can save you time and effort that would be spent writing YAML files from scratch. Plus, by storing the generated manifests in code repositories, you can use them declaratively as needed.

• Example:

Conclusion

Learning any new technology takes time and effort, but with Kubernetes, there are many ways you can make the learning process easier. First, get familiar with kubectl and its documentation. Second, learn some of the imperative commands, which will help you remember key commands and perform operations more quickly.

In this article, we’ve covered everything you need to know about imperative commands — what they are, when to use them and how to use them correctly. We’ve provided multiple examples of advanced imperative commands in action, so you can start using them for your own experiments and projects. Thanks for reading!‍

Squadcast is an incident management tool that’s purpose-built for SRE. Get rid of unwanted alerts, receive relevant notifications and integrate with popular ChatOps tools. Work in collaboration using virtual incident war rooms and use automation to eliminate toil.

Originally published at https://www.squadcast.com.