Kubectl - Kubernetes Command Center - The Kubernetes Workshop

10/16/22, 9:10 AM 3.
kubectl – Kubernetes Command Center | The Kubernetes Workshop
3. kubectl – Kubernetes
Command Center
Overview
In this chapter, we will demystify some common

kubectl commands and see how we can use
kubectl to control our Kubernetes cluster. We will
begin this chapter by taking a brief look at what
the end-to-end process looks like when using
kubectl commands to communicate with a
Kubernetes cluster. Then, we will set up a few
shortcuts and autocompletion for the Bash
terminal. We will begin with the basics of using
kubectl by learning how to create, delete, and
manage Kubernetes objects. We will learn about
the two approaches to managing resources in
Kubernetes - declarative and imperative - with
exercises. By the end of this chapter, you will also
have learned how to update a live application
running on your Kubernetes cluster in real-time
using kubectl.
Introduction
https://learning.oreilly.com/library/view/the-kubernetes-workshop/9781838820756/B14870_03_Final_SMP_ePub.xhtml 1/40
10/16/22, 9:10 AM 3. kubectl – Kubernetes Command Center | The Kubernetes Workshop
In Chapter 1, Introduction to Kubernetes and

Containers, we saw that Kubernetes is a portable
and highly extensible open-source container
orchestration tool. It provides very powerful
capabilities that can be used to manage
containerized workloads at scale. In the previous
chapter, you got the big picture of how the
different components of Kubernetes work
together to achieve the desired goals. We also
demonstrated some basic usage of kubectl in
Chapter 2, An Overview of Kubernetes. In this
chapter, we will take a closer look at this utility
and look at how we can make use of its potential.
To reiterate, kubectl is a command-line utility for

interacting with Kubernetes clusters and
performing various operations. There are two
ways to use kubectl while managing your cluster
- imperative management, which focuses on
commands rather than the YAML manifests to
achieve the desired state, and declarative
management, which focuses on creating and
updating YAML manifest files. kubectl can
support both these management techniques to
manage Kubernetes API objects (also called
Kubernetes API primitives). In the previous
chapter, we saw how the various components
constantly try to change the state of the cluster

from the actual state to the desired state. This
can be achieved by using kubectl commands or
YAML manifests.
kubectl allows you to send commands to

Kubernetes clusters. The kubectl command can
be used to deploy applications, inspect, and
manage Kubernetes objects, or troubleshoot and
view logs. Interestingly, even though kubectl is
the standard tool for controlling and
communicating with a Kubernetes cluster, it
doesn't come with Kubernetes. So, even if you
are running kubectl on any of the nodes of your
cluster, you need to install the kubectl binary
separately, which we did in Exercise 2.01, Getting
Started with Minikube and Kubernetes Clusters, in
the previous chapter.
This chapter will walk you through the behind-

the-scenes functionality of kubectl and provide
more insights into how to use kubectl commands
to interact with some commonly used
Kubernetes objects. We will learn how to set up
some shortcuts for kubectl. We will walk you
through not only creating new objects with
kubectl but also making changes to a live
Deployment in Kubernetes. But before that, let's

take a peek behind the curtains and get an idea
of exactly how kubectl communicates
with Kubernetes.
How kubectl Communicates

with Kubernetes
As we saw in the previous chapter, the API
server manages communications between the
end-user and Kubernetes, and it also acts as an
API gateway to the cluster. To achieve this, it
implements the RESTful API over the HTTP and
HTTPS protocols to perform CRUD operations to
populate and modify Kubernetes API objects
such as pods, services, and more based upon the
instructions sent by a user via kubectl. These
instructions can be in various forms. For
example, to retrieve information for pods
running in the cluster, we would use the
kubectl get pods command, while to create a
new pod, we would use the kubectl run
command.
First, let's take a look at what happens behind

the scenes when you run a kubectl command.
Take a look at the following illustration, which

provides an overview of the process, and then
we will take a closer look at the different details
of the process:
Figure 3.1: A representative flowchart for the

kubectl utility
A kubectl command is translated into an API call,

which is then sent to the API server. The API
server then authenticates and validates the
requests. Once the authentication and validation
stages have been successful, the API server
retrieves and updates data in etcd and responds
with the requested information.
Setting up Environments
with Autocompletion and
Shortcuts
In most Linux environments, you can set up
autocompletion for kubectl commands before
you start working with the instructions
mentioned in this chapter. Learning how
autocompletion and shortcuts work in Linux
environments will be significantly helpful for
those who are interested in getting certifications
such as Certified Kubernetes Administrator
(CKA) and Certified Kubernetes Application
Developer (CKAD), which are conferred by the
Linux Foundation. We'll learn how to set up
autocompletion in the following exercise.
Exercise 3.01: Setting up

Autocompletion
In this exercise, we will show you how to set up

autocompletion and an alias for kubectl
commands in Bash. This is a useful feature that
will help you save time and avoid typos. Perform
the following steps to complete this exercise:
1. We will need the bash-completion package,

so install it if it is not already installed. You can
go to the GitHub repository to get installation
instructions for various platforms, at
https://github.com/scop/bash-completion. If
you are running Ubuntu 20.04, you can install
it via the APT package manager using the
following command:
sudo apt-get install bash-
completion
2. You can use the following command to set up
autocomplete in Bash:
source <(kubectl completion
bash)
Note
This command, as well as the subsequent
commands in this exercise, will not show any
responses in the terminal upon successful
execution.
3. If you want to make autocomplete persistent in
your Bash shell, you can use the following
command, which will write kubectl
autocomplete to the .bashrc file in your
current user directory:
echo "source <(kubectl
completion bash)" >> ~/.bashrc
4. You can also set up an alias for your kubectl

commands by using the alias keyword, as
follows:
alias k=kubectl
5. Similarly, if you want to set up an alias for
some specific commands, you can use
commands similar to the following:
alias kcdp='kubectl describe po'
alias kcds='kubectl describe
svc'
alias kcdd='kubectl describe
deploy'
6. Finally, you can use the following command to
set up the completion of kubectl commands
when you press Tab:
complete -F __start_kubectl k
Note
You can also to set up autocomplete in zsh (an
alternative to the Bash shell) by using the
following commands:
source <(kubectl completion zsh)
echo "if [ $commands[kubectl] ]; then
source <(kubectl completion zsh); fi"
>> ~/.zshrc
By the end of this exercise, you will have an

autocomplete set up for your Bash shell. You can
also use aliases such as k instead of kubectl in

your commands. However, to avoid confusion
and maintain a standardized structure, we will
use the full commands throughout this book.
Setting up the kubeconfig

Configuration File
In most enterprise environments, there is

generally more than one Kubernetes cluster,
depending on the strategy of the organization.
An administrator, developer, or any other role
dealing with Kubernetes clusters would need to
interact with several of those clusters and switch
between them to perform different operations
on different clusters.
A configuration file makes things a lot easier.

You can use this file to store information about
different clusters, users, namespaces, and
authentication mechanisms. Such configuration
files are referred to as kubeconfig files. Note
that kubeconfig is a generic way to refer to
kubectl configuration files and that it is not the
name of the config file. kubectl uses such files
to store the information needed for us to choose
a cluster and communicate with its API server.
By default, kubectl looks for the file in the

$HOME/.kube directory. In most scenarios, you
can specify a KUBECONFIG environment variable
or use the --kubeconfig flag to specify the
kubeconfig files. Those files are usually saved in
$HOME/.kube/config.
Note
You can find out more about how to configure

access to multiple clusters by setting up the
KUBECONFIG environment variable and the --
kubeconfig flag at
https://kubernetes.io/docs/tasks/access-
application-cluster/configure-access-multiple-
clusters/#set-the-kubeconfig-environment-
variable.
Security contexts are used to define the privilege

and access control settings for the pods. We will
revisit the idea of access control and security in
Chapter 13, Runtime and Network Security in
Kubernetes.
Let's take a look at the kubeconfig file to

understand how this works. You can view the
kubeconfig file using the following command:
kubectl config view

Alternatively, you can also use the following

command:
cat $HOME/.kube/config
You should get an output similar to the
following:
Figure 3.2: The output of kubectl config view

command
A context is a set of information that you need

to access a cluster. It contains the name of the
cluster, the user, and the namespace. The
current-context field in Figure 3.2 shows the
current context that you are working with. If you
want to switch the current context, you can use
the following command:
kubectl config use-context <the

cluster you want to switch to>
For example, if we wanted to switch to a context

named minikube, we would use the following
command:
kubectl config use-context

minikube
This would give an output similar to the
following:
Switched to context "minikube".
Common kubectl
Commands
As previously described, kubectl is a CLI tool that
is used to communicate with the Kubernetes API
server. kubectl has a lot of useful commands for
working with Kubernetes. In this section, we're
going to walk you through some commonly used
kubectl commands and shortcuts that are used to
manage Kubernetes objects.
Frequently Used kubectl Commands

to Create, Manage, and Delete
Kubernetes Objects
There are several simple kubectl commands that

you will use almost all the time. In this section,
we will take a look at some of the basic kubectl

commands:
get <object>: You can use this command to

get the list of the desired types of objects. Using
all instead of specifying an object type will
get the list of all kinds of objects. By default,
this will get the list of specified object types in
the default namespace. You can use the -n flag
to get objects from a specific namespace; for
example, kubectl get pod -n
mynamespace.
describe <object-type> <object-name>:
You can use this command to check all the
relevant information of a specific object; for
example, kubectl describe pod mypod.
logs <object-name>: You can use this
command to check all the relevant logs of a
specific object to find out what happened
when that object was created; for example,
kubectl logs mypod.
edit <object-type> <object-name>: You
can use this command to edit a specific object;
for example, kubectl edit pod mypod.
delete <object-type> <object-name>:
You can use this command to delete a specific
object; for example, kubectl delete pod

mypod.
create <filename.yaml>: You can use this
command to create a bunch of Kubernetes
objects that have been defined in the YAML
manifest file; for example, kubectl create -
f your_spec.yaml.
apply <filename.yaml>: You can use this
command to create or update a bunch of
Kubernetes objects that have been defined in
the YAML manifest file; for example, kubectl
apply -f your_spec.yaml.
Walkthrough of Some Simple

kubectl Commands
In this section, we're going to walk you through
some of the commonly used kubectl commands.
This section is mostly for demonstration
purposes, so you may not see the exact output
that you see in these images. However, this
section will help you understand how these
commands are used. You will use most of them
extensively in later exercises, as well as
throughout this book. Let's take a look:
If you want to display nodes, use the following

command:
kubectl get nodes
You will see an output similar to the following:
Figure 3.3: The output of kubectl get nodes

command
Since we set up aliases in Exercise 3.01, Setting up

Autocompletion, you can also get the same result
using the following command:
k get no
If you want to display all current namespaces,

you can use the following command:
kubectl get namespaces
You should see an output similar to the
following:
NAME STATUS AGE
default Active 7m5s
kube-node-lease Active 7m14s
kube-public Active 7m14s
kube-system Active 7m15s
You can also get the same result using the
following shortened command:
k get ns
If you want to check the version of kubectl,

you can use the following command:
kubectl version
You will see an output similar to the following:
Client version:
version.Info{Major:"1",
Minor:"17", GitVersion:"v1.17.2,
GitCommit:
59603c6e503c87169aea6106f57b9f24
2f64df89", GitTreeState:"clean",
BuildDate:"2020-01-21T22:17:28Z,
GoVersion:"go1.13.5",
Compiler:"gc",
Platform:"linux/amd64}
Server version:
version.Info{Major:"1",
Minor:"17", GitVersion:"v1.17.2,
GitCommit:
59603c6e503c87169aea6106f57b9f24
2f64df89", GitTreeState:"clean",
BuildDate:"2020-01-18T23:22:30Z,
GoVersion:"go1.13.5",
Compiler:"gc",
Platform:"linux/amd64}
If you want to see some information regarding
your current Kubernetes cluster, you can use
kubectl cluster-info
following:
Figure 3.4: The output of kubectl cluster-info

command
Before we move on further with the

demonstrations, we will mention a few
commands that you can use to create a sample
application, which we have already provided in
the GitHub repository for this chapter. Use the
following command to fetch the YAML
specification for all the objects required to run
the application:
curl
https://raw.githubusercontent.com/
PacktWorkshops/Kubernetes-
Workshop/master/Chapter03/Activity
03.01/sample-application.yaml --
output sample-application.yaml
Now, you can deploy the sample-
application.yaml file using the
following command:
kubectl apply -f sample-

application.yaml
If you can see the following output, this means
that the sample application has been successfully
created in your Kubernetes cluster:
deployment.apps/redis-back created
service/redis-back created
deployment.apps/melonvote-front
created
service/melonvote-front created
Now that you have deployed the provided
application, if you try any of the commands
shown later in this section, you will see the
various objects, events, and so on related to this
application. Note that your output may not
exactly match the images shown here:
You can use the following command to get

everything in your cluster under the default
namespace:
kubectl get all
This will give an output similar to the
following:
Figure 3.5: The output of kubectl get all

command
Events describe what has happened so far in

the Kubernetes cluster, and you can use events
to get a better insight into your cluster and aid
in any troubleshooting efforts. To list all the
events in the default namespace, use the
following command:
kubectl get events
following:
Figure 3.6: The output of kubectl get events

command
A service is an abstraction that's used to

expose an application to the end-user. You will
learn more about services in Chapter 8, Service
Discovery. You can use the following command

to list all services:
kubectl get services
following:
Figure 3.7: The output of kubectl get services

command
You can get the same result using the following

shortened command:
k get svc
A Deployment is an API object that allows us to

easily manage and update pods. You will learn
more about Deployments in Chapter 7,
Kubernetes Controllers. You can get the list of
Deployments using the following command:
kubectl get deployments
This should give a response similar to the
following:
NAME READY UP-TO-DATE AVAILABLE
AGE
aci-helloworld 1/1 1 1 34d
melonvote-front 1/1 1 1 7d6h
redis-back 1/1 1 1 7d6h
You can also get the same result using the

following shortened version of the command:
k get deploy
Some Useful Flags for the get Command
As you have seen, the get command is a pretty

standard command that is used when we need to
get the list of objects in our cluster. It also has
several useful flags. Let's take a look at a few of
them here:
If you want to list a particular type of resource

from all your namespaces, you can add the --
all-namespaces flag in the command. For
example, if we want to list all Deployments
from all namespaces, we can use the following
command:
kubectl get deployments --all-
namespaces
This will give an output similar to this:
Figure 3.8: The output of kubectl get

deployments under all namespaces
You can also see that there is an additional

column on the left-hand side that specifies the
namespaces of the respective Deployments.
If you want to list a specific type of resource

from a specific namespace, you can use the -n
flag. Here, the -n flag stands for namespace.
For example, if you want to list all
Deployments in a namespace called keda, the
following command would be used:
kubectl get deployments -n keda
This command would show an output similar
to the following:
Figure 3.9: The output of kubectl get

deployments under the keda namespace
You can add the --show-labels flag to

display the labels of the objects in the list. For
example, if you wanted to get the list of all the
pods in the default namespace, along with
their labels, you would use the following
command:
kubectl get pods --show-labels

This command should give an output similar
to the following:
Figure 3.10: The output of kubectl get pods with

all labels
There is an additional column on the right-hand

side that specifies the labels of the pods.
You can use the -o wide flag to display more

information about objects. Here, the -o flag
stands for output. Let's look at a simple
example of how to use this flag:
kubectl get pods -o wide
following:
Figure 3.11: The output of kubectl get pods with

additional information
You can also see there are additional columns on

the right-hand side that specify which nodes the
pods are running on, as well as the internal IP
addresses of the node. You can find more ways to
use the -o flag at
https://kubernetes.io/docs/reference/kubectl/overview/#outpu
options.
Note
We will limit this section to commands that are

commonly used to limit the scope of this chapter.
You can find a lot more kubectl commands at
https://kubernetes.io/docs/reference/generated/kubectl/kubectl-
commands.
Populating Deployments in
Kubernetes
As we mentioned earlier, Deployment is a
convenient way to manage and update pods.
Defining a Deployment in Kubernetes is an
effective and efficient way to provide declarative
updates for the application running in your
cluster.
You can create a Deployment by using kubectl

imperative commands or by using declarative
YAML manifest files. In the following exercise,
we're going to deploy an application (we will go
with Nginx for this exercise) in Kubernetes and
learn how to interact with Deployments using
kubectl commands, as well as how to modify the

YAML manifest file.
Exercise 3.02: Creating a Deployment
There are two ways to create a Deployment in

Kubernetes – using the kubectl create/run
command and creating a manifest file in YAML
format and then using the kubectl apply
command. We can achieve the same goal with
those two options. Let's try both and then
compare them:
1. Create a Deployment using the following

command directly:
kubectl create deployment
kubeserve --image=nginx:1.7.8
You can expect an output similar to the
following:
deployment.apps/kubeserve
created
Note
You can also create a Deployment using the
kubectl run command. To achieve the same
results here, you could use the following
commands:
kubectl run nginx --image=nginx:1.7.8
kubectl run nginx --image=nginx:1.7.8

--replicas=3
2. You can also create a Deployment by defining
the YAML manifest file for your Deployment.
Use your preferred text editor to create a file
named sample-deployment.yaml with the
following content:
apiVersion: apps/v1
kind: Deployment
metadata:
name: kubeserve
labels:
app: kubeserve
spec:
replicas : 3
selector:
matchLabels:
app: kubeserve
template:
metadata:
labels:
app: kubeserve
spec:
containers:
- name: nginx
image: nginx
ports:
- containerPort: 80
In this YAML definition, the replicas field
defines the number of replica pods in this
Deployment.
3. Use the following command to apply the
configuration you've defined in the YAML
manifest file:
deployment.yaml
The sample output will look as follows:
deployment.yaml
4. Use the following command to check the
Deployments that currently exist in the
default namespace:
kubectl get deployments
The output will look as follows:
AGE
kubeserve 3/3 3 3 26m
In this exercise, we have seen the differences in

using the different approaches to create a
Deployment. The kubectl create command is
widely used for testing. For most enterprise
solutions where modern DevOps approaches are

implemented, it makes more sense to use YAML
definitions to conveniently define
configurations, and then track them with source
control tools such as Git. When your
organization integrates YAML definitions with
DevOps tools, it makes the solution more
manageable and traceable.
Now that we have seen how to create a

Deployment, in the next exercise, we will learn
how to modify or update a Deployment that is
already running. This is something that you will
need to do quite often as the software is updated
to new versions, bugs are identified and fixed,
the demands on your application change, or
your organization moves on to completely new
solutions. We will also learn how to roll back a
Deployment to an earlier version, which is
something that you will want to do if an update
does not lead to the expected outcome.
Exercise 3.03: Updating a

Deployment
In this exercise, we will update the application
that we deployed in the previous exercise to a
more recent version and demonstrate how we

can roll back the Deployment to a previous
version if necessary.
Similar to the two approaches that we saw for

creating a Deployment, there are two ways to
update an application as well – using the
kubectl set image command and updating
the YAML manifest file and then using the
kubectl apply command. These steps will
guide you through both approaches:
1. First, let's get the details of the current

Deployment using the following command:
kubectl describe deploy
kubeserve
You'll get an output similar to the following:
Figure 3.12: Describing the kubeserve

Deployment
2. You can update the image using the following
command:
kubectl set image
deployment/kubeserve
nginx=nginx:1.9.1 –-record
The image subcommand indicates that we

want to update the image field of the object, as
defined in the YAML manifest that we saw in
Step 2 of the previous exercise.
Then, we specify the object in the <object-
type>/<object name> format.
The next part, nginx=nginx:1.9.1, tells
Kubernetes to look for the specific image
tagged as 1.9.1 in the Docker Hub repository
of NGINX. You can check out the available tags
at https://hub.docker.com/_/nginx?tab=tags.
The --record flag is very helpful when you
want to save the updates that have been made
by your kubectl commands to the current
resource.
By applying this, you'll get an output similar to
the following:
deployment.extensions/kubeserve
image updated
3. Now, let's get the details of the Deployment
kubectl describe deploy
kubeserve
You should see the following output:
Figure 3.13: Using the kubectl describe

command to check the image version in the
container
In the preceding screenshot, you can see that
the image has been successfully updated to
version 1.9.1.
Another way to achieve the same result is to
modify the YAML file and then use the
kubectl apply command. We will use the
same YAML file that we created in the previous
exercise. If you do not have the YAML file for
an object, you can export the YAML manifest
kubectl get deploy kubeserve -o
yaml > kubeserve-spec.yaml
This command will output a file named
kubeserve-spec.yaml with the manifest that
is in effect in the cluster. Then, you can use
vim, nano, or any other text editor to edit it
and then apply the edited kubeserve-
spec.yaml manifest using the kubectl
apply command, as shown in the previous
exercise, with the addition of the --record

flag.
4. If you want to perform a rollback, you can use
kubectl rollout undo deployments
kubeserve
You'll see an output similar to the following:
rolled back
5. You can use the kubectl rollout history
command to check all the revisions for a
specific Deployment, as shown here:
kubectl rollout history
deployment kubeserve
Figure 3.14: The output of the kubectl rollout

history command
6. You can also use the following command to
check the details of a specific revision:
kubectl rollout history
deployment kubeserve --
revision=3
The output for this command will be as
follows:
Figure 3.15: Checking the details of revision 3

7. You can roll back a Deployment to a specific
revision by specifying the --to-revision
flag:
kubectl rollout undo deployments
kubeserve --to-revision=3
rolled back
In this exercise, we have learned how to update

an already existing Deployment, as well as how
to roll back a Deployment to its earlier specs.
Deployments allow us to define a desired state

for the replica pod in a declarative way. We will
revisit how Deployment works and discover
more about it in Chapter 7, Kubernetes
Controllers. If you delete the individual pod
replica intentionally or if the pod fails for any
reason, since we define a Deployment with a set
number of replicas, the Deployment will keep
recreating the pod as many times as you delete
it. This is what we call auto-healing. Therefore,
you need to delete the Deployment itself, which

will also delete all the pods managed by it. We
will learn how to do that in the following
exercise.
Exercise 3.04: Deleting a Deployment
In this exercise, we will delete the Deployment

we created in the previous exercise:
1. Get a list of existing Deployments using the

following command:
kubectl get deployment
You can expect an output similar to the
following:
AGE
kubeserve 3/3 3 3 26m
melonkedaaf 0/0 0 0 26d
2. Let's say that, for the purpose of this exercise,
we want to delete the kubeserve Deployment
that we created in the previous exercise. Use
the following command to delete the
Deployment:
kubectl delete deployment
kubeserve
The sample output will be similar to the

following:
deployment.extensions
"kubeserve" deleted
3. Get the list of Deployments to check and make
sure that the target Deployment has been
deleted successfully:
kubectl get deployment
following:
AGE
kubeserve 0/0 0 0 26d
You can use the kubectl delete command to

delete any other object as well. However, as we
mentioned earlier, in cases such as pods
managed by Deployments, it is pointless to delete
individual pods as the Deployment will just
recreate them, so you need to delete the
Deployment.
Activity 3.01: Editing a Live

Deployment for a Real-Life
Application
Imagine that you are a SysOps engineer who has

been asked to manage a cluster and deploy a
web application. You have deployed it to your
Kubernetes cluster and made it available to the
public. You have been monitoring this
application ever since it was deployed
successfully, and you've detected that the web
application has been experiencing throttling
issues during peak times. Based on your
monitoring, the solution that you want to
implement is to assign more memory and CPU to
this application. Therefore, you need to edit the
Deployment so that you can allocate enough CPU
and memory resources to run the application
and test this application at the end. You need to
demonstrate that your web application is up and
running and that it can be accessed through a
public IP address via a browser of your choice.
To simulate this scenario, we're going to deploy a

sample application in a Kubernetes cluster and
show you how to edit a live Deployment. Editing
a live Deployment is something that you will
need to do when fixing issues or for testing
purposes.
You can use the following command to get the

YAML manifest file that you're going to use in
this activity:
curl
https://raw.githubusercontent.com/
PacktWorkshops/Kubernetes-
Workshop/master/Chapter03/Activity
03.01/sample-application.yaml --
output sample-application.yaml
This manifest file defines all the different objects
that are required to run the application, as well
as the application itself.
Note
This manifest has been adapted from an open-

source sample provided by Microsoft Azure,
available at https://github.com/Azure-
Samples/azure-voting-app-redis.
Perform the following steps to complete this

activity:
1. First, deploy the target web application using

the kubectl apply command and the
provided YAML definition file.
2. Get the IP address of the service that exposes
your application. For this simple scenario, this
will be similar to Exercise 2.03, Accessing a Pod

via a Service, from the previous chapter. Later
chapters will explain how to work with ingress
controllers and create ingress resources to
expose the frontend applications.
3. Use the kubectl edit command to edit the
live deployment. You will need to edit the
deployment named melonvote-front. The
following are the fields that you need to
modify to satisfy the requirements of this
scenario. You can simply double these values:
a) resources.limits.cpu: This is the
resource limit for CPU usage.
b) resources.limits.memory: This is the
resource limit for memory usage.
c) resources.requests.cpu: This is the
minimum CPU usage requested to get your
application up and running.
d) resources.requests.memory: This is the
minimum memory usage requested to get your
application up and running.
By the end of this activity, you will be able to see

the UI of the application that you deployed with
Kubernetes:
Figure 3.16: Expected output of the activity
Note
The solution to this activity can be found at the

following address: https://packt.live/304PEoD.
Summary
This chapter demystified how kubectl allows us
to control our Kubernetes cluster using API calls.
First, we learned how to set up an environment
for kubectl commands and looked at a number
of shortcuts. Furthermore, we covered how to
create, edit, and delete a Kubernetes object using
kubectl commands and looked at a Deployment
as an example. Finally, we deployed a real-life
application and showed you how to edit a live
Deployment. Every example in this chapter has
been applied in a general context; however, we
believe that the skills developed in this chapter
can help you resolve specific problems that you
might encounter in a professional environment.
In the next chapter, you'll explore the other side

of this bridge and dive deeper into how the API
server works. You will also take a closer look at
REST API requests and how the API server deals
with them.
Support Sign Out
©2022 O'REILLY MEDIA, INC. TERMS OF SERVICE PRIVACY POLICY

Kubectl - Kubernetes Command Center - The Kubernetes Workshop

Uploaded by

Copyright:

Available Formats

You might also like

Kubectl - Kubernetes Command Center - The Kubernetes Workshop

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kubectl - Kubernetes Command Center - The Kubernetes Workshop

Uploaded by

Copyright:

Available Formats

10/16/22, 9:10 AM 3.

kubectl – Kubernetes Command Center | The Kubernetes Workshop

In this chapter, we will demystify some common

In Chapter 1, Introduction to Kubernetes and

To reiterate, kubectl is a command-line utility for

constantly try to change the state of the cluster

kubectl allows you to send commands to

This chapter will walk you through the behind-

Deployment in Kubernetes. But before that, let's

How kubectl Communicates

First, let's take a look at what happens behind

Take a look at the following illustration, which

Figure 3.1: A representative flowchart for the

A kubectl command is translated into an API call,

Exercise 3.01: Setting up

In this exercise, we will show you how to set up

1. We will need the bash-completion package,

4. You can also set up an alias for your kubectl

By the end of this exercise, you will have an

also use aliases such as k instead of kubectl in

Setting up the kubeconfig

In most enterprise environments, there is

A configuration file makes things a lot easier.

By default, kubectl looks for the file in the

You can find out more about how to configure

Security contexts are used to define the privilege

Let's take a look at the kubeconfig file to

kubectl config view

Alternatively, you can also use the following

Figure 3.2: The output of kubectl config view

A context is a set of information that you need

kubectl config use-context <the

For example, if we wanted to switch to a context

kubectl config use-context

Switched to context "minikube".

Frequently Used kubectl Commands

There are several simple kubectl commands that

we will take a look at some of the basic kubectl

get <object>: You can use this command to

object; for example, kubectl delete pod

Walkthrough of Some Simple

If you want to display nodes, use the following

Figure 3.3: The output of kubectl get nodes

Since we set up aliases in Exercise 3.01, Setting up

If you want to display all current namespaces,

If you want to check the version of kubectl,

Figure 3.4: The output of kubectl cluster-info

Before we move on further with the

kubectl apply -f sample-

You can use the following command to get

Figure 3.5: The output of kubectl get all

Events describe what has happened so far in

Figure 3.6: The output of kubectl get events

A service is an abstraction that's used to

Discovery. You can use the following command

Figure 3.7: The output of kubectl get services

You can get the same result using the following

A Deployment is an API object that allows us to