Using kubectl delete | Tutorial and best practices (2023)

The Kubernetes command line tool,kubectl, provides a way to communicate with theKubernetes-Clusterthrough the control plane to manage resources by creating, editing, and extracting details about specific resources. The tool contains a number of commands that can be used to perform various tasks.

One of the commands associated with this tool is the <terminal inline>kubectl delete<terminal inline> command. This command allows you to gracefully shut down running resources. Some of the use cases for the <terminal inline>kubectl delete<terminal inline> command include theTermination of running pods, Implementations, Services, StatefulSets and many other resources.

In this guide, you'll learn how to properly use <terminal inline>kubectl delete<terminal inline> to stop resources, and learn about the various parameters this command exposes. You will learn some best practices to guide you in using this command safely and correctly.

What is kubectl removal?

kubectl delete gives you the ability to gracefully close and terminate Kubernetes resources based on their specific filenames or resource names. Gracefully terminating resources with the <terminal inline>kubectl delete<terminal inline> command should be done with the utmost discretion, since once the command has run, there is no way to undelete the resource.

Kubernetes does not provide users with the ability to pause and resume resources. There are several ways to work around this limitation. One of them is to simply stop (delete) the desired resource to pause it and reapply the resource definition to the cluster to resume it.

The <terminal inline>kubectl delete<terminal inline> command is particularly useful when cleaning up an application after deployment. During development, the creation and deployment of resources is a major concern, but managing those resources sometimes falls by the wayside after deployment.

Some of these resource management tasks include removing unused pods. While these pods are running and not being used in the Kubernetes cluster, they consume some of the node's resources, limiting other, more important running pods.

In some cases, aKubernetes nodeIt should be shut down and Kubernetes services and deployments must be stopped. Another resource management issue might be the removal of StatefulSets that manage pods that depend on persistent storage configurations, e.g. B. Persistent Volumes.

Remove with kubectl

Before starting this tutorial, you should understand the following Kubernetes concepts:

• Debt
• stateful sentences
• Replikat-Sets
• Calls
• Services
• kubectlCommand line tool

To begin using <terminal inline>kubectl delete<terminal inline> , you must have a single-node Kubernetes cluster running with at least 4 GB of available RAM. You can create one locally with simple Kubernetes distributions, e.gMinikube,K3s, ÖMicroK8s, or you can purchase one from a cloud provider such asGoogles Kubernetes Engine(ONG),Azure Kubernetes service, ÖService Amazon Elastic Kubernetes(EXP).

Basic use case to remove kubectl

Now that your cluster is set up, you can get started with a basic use case of the <terminal inline>kubectl delete<terminal inline> command.

Deploy an example NGINX deployment by creating a file named <terminal inline>deployment.yaml<terminal inline> and then adding the following code snippet:

apiVersion: apps/v1kind: deployment metadata: name: nginx deployment labels: application: nginxspec: replicas: 3 selector: matchLabels: application: nginx template: metadata: labels: application: nginx specification: container: - name: nginx image: nginx: 1.14.2 Ports: - ContainerPort: 80

Then run the configurations on your Kubernetes cluster using <terminal inline>kubectl apply<terminal inline>Domain:

kubectl apply -f ./deployment.yaml

The above command creates an NGINX deployment with a ReplicaSet and three NGINX Pods deployed and running on the default <Inline-Terminal><Inline-Terminal>namespaceon your Kubernetes cluster. To check this, you can just run <terminal inline>kubectl get pod<terminal inline> command and get the following response:

After you have successfully deployed NGINX to your Kubernetes cluster, the next step is to post-deployment cleanup.

If you run the <terminal inline>kubectl delete pods --all<terminal inline> command to delete all NGINX pods in the default namespace, a different set of pods reappears to replace the deleted ones. To prevent this, you should delete the deployment configuration with filename <inline terminal>deployment.yaml<inline terminal> or deployment name <inline terminal>nginx-deployment<inline terminal> as shown in the < terminal inline>metadata<terminal section inline> in the YAML snippet above.

The NGINX implementation can be removed in two ways:

# Delete deployment with filenamekubectl delete -f ./deployment.yaml# Delete deployment with metadata name:kubectl Delete deployment nginx deployment

After the deployment resource is deleted, you should not be able to see any pods, deployments, or ReplicaSets in the <terminal inline>default<terminal inline> namespace. You only see a single active Kubernetes service when you run the <terminal inline>kubectl get services<terminal inline> command:

Get kubectl services

This will display the services available in the <terminal inline>default<terminal inline> namespace:

Please note that depending onKubernetes distribution typeis running, the output shown above may vary slightly.

Advanced use case to remove kubectl

In the previous section, you created a simple NGINX implementation and then successfully removed it. In this section, you'll see a more advanced use case for the <terminal inline>kubectl delete<terminal inline> command and walk through the steps required to use the command.

In this example, you will implement the popular WordPress CMS. To do this, create the WordPress service <terminal inline>wp-pv-claim<terminal inline> PersistentVolumeClaim and deploy the WordPress app with the latest Docker Hub image.

Using your favorite text editor, create a file named <terminal inline>wordpress.yaml<terminal inline> and paste the following YAML code:

apiVersion: v1kind: Servicemetadata: name: wordpress tags: application: wordpressspec: ports: - port: 80 selector: application: wordpress tier: frontend type: LoadBalancer---apiVersion: v1kind: PersistentVolumeClaimmetadata: name: wp-pv-claim tags: app: wordpressspec: accessModes: -ReadWriteOnce Resources: Requests: Storage: 1Gi---apiVersion: apps/v1kind: Deploymentmetadata: Name: WordPress Labels: app: wordpressspec: selector: matchLabels: app: wordpress level: interface strategy: type: Rebuild Template: Metadata: Tags: Application: WordPress Layer: Frontend Specification: Container: - Image: Wordpress:5.9.3-Apache Name: Wordpress env: - Name: WORDPRESS_DB_HOST Value: Wordpress DB - Name: WORDPRESS_DB_PASSWORD Value: Password Ports: - containerPort: 8080 name: wordpress volumeMounts: - name: wordpress-persistent-storage mountPath: /var/www/html volumes: - name: wordpress-persistent-storage persistentVolume eClaim: ClaimName: wp-pv-claim

Apply the above configuration to your cluster by running the <terminal inline>kubectl apply<terminal inline> command:

kubectl describes the deployment test web application

You will see output similar to the following:

$ kubectl apply -f ./wordpress.yml service/wordpress createdpersistentvolumeclaim/wp-pv-claim createddeployment.apps/wordpress created

Verify that the changes were made correctly by using the <terminal inline>kubectl get all<terminal inline> command:

kubectl get everything

You should get an output similar to this:

NAME READY STATUS RESTART AGEpod/svclb-wordpress-4r66v 1/1 Running 0 25spod/wordpress-66ff8d4cb4-k746r 1/1 Running 0 25sNAME TYPE CLUSTER IP EXTERNAL IP PORT(S) AGEservice/kubernetes ClusterIP 10.43.0.1 < none> 443/TCP 9dservice/wordpress LoadBalancer 10.43.130.141 172.19.0.2 8080:32552/TCP 25s CURRENT NAME DESIRED READY UPDATED NODE SELECTION AVAILABLE AGEdaemonset.apps/svclb-wordpress 1 1 1 1 1 <noneUPDATE/DATED.appyploment.depressment/1.appyploment.depressment AGE> 25s AGE 1 1 25s CURRENT DESIRED NAME READY AGErepliset.apps/wordpress-66ff8d4cb4 1 1 1 25s

After verifying that the WordPress deployment was successful, you can proceed with the cleanup.

As before, trying to delete the pods is useless as the implementation specification recreates them as many times as needed. Fortunately, you only have to use one command to delete the newly created implementation, service, and PVC:

$ kubectl delete -f ./wordpress.yamlservice "wordpress" eliminatedpersistentvolumeclaim "wp-pv-claim" eliminateddeployment.apps "wordpress" eliminated

If you want, you can confirm the above output with the commands:

kubectl getserviceskubectl Retrieves persistent volume claims

The output should look something like this:

Another way to check that there are no traces of WordPress left is to use the <terminal inline>kubectl get all<terminal inline> command again:

As you can see, the <terminal inline>kubectl delete<terminal inline> command is useful for both simple and more advanced use cases.

However, note that this was possible because a single YAML file was used to configure all moving parts. This may or may not be a good idea as you could accidentally delete even data stored on onesustained volume. This brings us to the next section, Best Practices.

Better Practices

A single misused <terminal inline>kubectl delete<terminal inline> command can destroy an entire application and render it unusable. There are no safety precautions such as B. Prompts to ask if you really want to delete the resource or not attached to the command. Before you perform any operation with the <terminal inline>kubectl delete<terminal inline> command, you need to know exactly what you want to delete and how you want to delete it.

You can use the <terminal inline>kubectl delete --help<terminal inline> command to see a list of flags and options that can be applied.

Know when and how to use kubectl delete

To understand when to delete Kubernetes resources, you need to understand your application's tolerance for the unavailability of one or more resources. If any of the resources are removed, your app should continue to work.

Likewise, knowing how resources are cleared is important to keep your services and applications running. For example, removing resources should be avoided when the <terminal inline>--force<terminal inline> flag is set to <terminal inline>true<terminal inline> , as this may result in a resource inconsistency that may cause an application runtime error or would cause data loss. . Unless you are very sure that this will not cause problems for your application, this should only be used as a last resort.

Use kubectl delete only when absolutely necessary

It is highly recommended that you use the <terminal inline>kubectl delete<terminal inline> command sparingly unless you are performing critical operations such as: B. Cleanup operations for resource optimization.

It is also recommended to defer removing PersistentVolumeClaims until all necessary data has been restored or copied by using the <terminal inline>kubectl cp<terminal inline> command from <terminal inline>mountPath<terminal inline> on your host machine.

final thoughts

In this article, you learned about the <terminal inline>kubectl delete<terminal inline> command: what it is, the different use cases, and recommended uses.

The <terminal inline>kubectl delete<terminal inline> command can be very useful when managing resources, but it's important to note that while you can prevent bottlenecks in your application, so can <terminal inline>kubectl delete<terminal inline> Discontinue your application completely if used carelessly.

Kubernetes deployments are best paired with a monitoring solution like ContainIQ, which allows you to keep an eye on your resources, analyze logs and track potential issues in your application, keep you informed about the health of your cluster, and Your cluster better manage resources. .