What news from AWS re:Invent last week will have the most impact on you?
Amazon Q, an AI chatbot for explaining how AWS works.
Super-fast S3 Express storage.
New Graviton 4 processor instances.
Emily Freeman leaving AWS.
I don't use AWS, so none of this will affect me.
DevOps / Kubernetes / Software Development

Introduction to Kubernetes Imperative Commands

While great for learning, imperative commands don't give you full access to the Kubernetes API. They're mostly used to create YAML manifests and objects on the go.
Dec 2nd, 2022 8:05am by
Featued image for: Introduction to Kubernetes Imperative Commands
Image via Unsplash.

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 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.

Command Pros Cons
Declarative The chance for human error is low when the YAML manifest is already present. If you don’t have YAML manifests, you cannot use declarative commands.
Imperative Since you can create objects on the fly with these commands, productivity is increased. This is especially useful when you need to create an object quickly and don’t have time to go through the process of creating it from scratch. There’s an increased chance of human error when every configuration has to be specified in one-liners.

A 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.


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.

  • The syntax for kubectl’s imperative command to create objects can be summarized as follows:

kubectl create <type-of-object> [<subtype-of-object>] <name-of-object> <properties>

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 nodeportservice is pretty simple and can be summarized as follows:

kubectl create service nodeport <name-of-service> <properties>

  • An example of the above syntax:

kubectl create service nodeport my-ns --tcp=5678:8080

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:

kubectl create secret generic <name-of-secret>

  • An example of the above syntax:

kubectl create secret generic my-secret --from-literal=key1=supersecret


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.

kubectl create configmap <name> --from-literal=<key>=<value>

kubectl create configmap cm123 --from-literal=name=squadcast

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

kubectl create deployment <name> --image=<image> --replicas=<replicas>

kubectl create deployment squadcast --image=ubuntu --replicas=2

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

kubectl create job <name> --image=<image> -- <command> <argument>

kubectl create job squadcast --image=ubuntu -- sleep 200

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


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:

kubectl expose deployment <name-of-deployment> --type=<type> --port=<port> --target-port=<target-port> --name=<name-of-svc>

  • An example of the above syntax:

kubectl expose deployment nginx --type=ClusterIP --port=8080 --target-port=80 --name=nginx-clusterip-svc


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 ubuntuis as follows:

kubectl run <pod-name> --image=<image>

  • An example of the above syntax:

kubectl run ubuntu --image=ubuntu

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.


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:

kubectl explain pods

kubectl explain pods.spec.containers

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

kubectl explain pod --recursive

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:

kubectl create deployment squadcast --replicas=3 --image=ubuntu **--dry-run=client -o yaml** > squadcast-deployment.yaml


Learning any new technology takes time and effort, but with Kubernetes, there are a few 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!

Group Created with Sketch.
TNS owner Insight Partners is an investor in: Pragma, Docker.
THE NEW STACK UPDATE A newsletter digest of the week’s most important stories & analyses.