To understand the concept of Docker containers or containerization in general, it’s important to first understand the Docker container lifecycle. Maintaining a microservice application deployed through containers with complex requirements is not easy. To add to it, the only possible way to maintain Docker containers is through a command line. Hence, keeping track of each Docker container through a single command line becomes difficult.

Docker comes packed with tools and commands to manage our containers in the most efficient manner. Hence, leveraging these commands will make your lives a lot easier. If you know your Docker container commands, spinning up a Docker container is just a piece of cake.

In this tutorial of the Docker tutorial series, we will discuss the Docker container lifecycle in detail. We will discuss all the possible states in the Docker lifecycle and see how to manage containers in all these states with the help of corresponding Docker commands.

You can use the Docker push command to push images to the Docker hub. Docker hub allows us to create repositories where we can store and manage Docker images. Repositories are a set of similar images identified by their tags. For example, Docker contains several versions of Ubuntu images inside the Ubuntu repository. Each Ubuntu image is identified by a separate tag such as xenial, 18.04, 20.04, focal, etc.

Pushing images to the Docker hub is fairly simple. Once you have pushed images to the Docker hub, you can easily share them with your organization members. In fact, you can even use the Docker push command to push images to your private and locally hosted repositories. You can create local private registries using the registry image that the Docker hub provides.

In this article we will learn what the NTP is, how to sync your server time and date using systemd-timesyncd network time service, and how to change the timezone in Linux.

You can easily keep your system’s date and time accurate by using NTP (Network Time Protocol). It lets you to synchronize computer clocks through network connections and keep them accurate. Basically a client requests the current time from a remote server, and uses it to set its own clock.

Ubuntu 21.04 was made available last month, and it has been quite the hit with both end users and businesses. Although you won't find a massive amount of new features, what is there should be considered a significant step forward for enterprise and other business use cases.

One particular feature that network and security admins will greatly appreciate is the ability to easily connect Ubuntu Desktop to an Active Directory domain. With this newly added ability, Linux desktops have become a more viable option for companies. The added benefit of this is users will be working on a more reliable and secure platform.

We can use the Docker tag command to add metadata to Docker images. They convey essential information about the version of a specific image. Docker registries such as Docker hub store images in repositories. A repository is a set of similar images but different versions identified using tags. For example, the Ubuntu repository in the Docker hub has several Ubuntu images, but all of them have different tags such as 18.04, focal, xenial, bionic, etc.

Docker tag is just a way to refer to a particular version of an image. A fair analogy is how we use Git tags to refer to specific commits in history. We can use Docker tags to provide specific labels to an image. They can be considered an alias to image IDs.

If you’ve been around for a while in the world of computers and, why not, even cybersecurity, you may have heard the term checksum thrown around here and there, even in casual “How have you been” conversations. That’s mainly because checksums are still a reliable way to assess whether or not a batch of data or a single item corresponds to certain parameters or has suffered various modifications.

Docker provides us with various tools and utilities to create, manage, and share applications in isolated and packaged environments called containers. It uses multi-layered read-only templates called images to define the container environment which will run our application. We can use some important Docker image commands to maintain and manipulate Docker images easily.

After having worked with Docker for a considerable amount of time, you might have several Docker images already in your system. If you don’t know the basic image commands, it might be very difficult to manage such a huge number of images. To make this easier, Docker allows us to use simple image commands in the command-line to easily manage tons of images simultaneously.

When it comes to the personalization and customizability of Linux desktops, the KDE Plasma desktop environment takes the cake with an incredible amount of themes and tweaks. It offers a wide range of options to make your desktop look unique.

While customizing the icons or splash screen are straightforward in KDE Plasma, not many people know that you can change the login screen theme. This article is there to help you out.

Docker logs provide essential information about the commands and processes that are being executed inside the container. This is helpful in cases when your containers fail to work or gets crashed. You can tail Docker logs to find the exact set of commands that were responsible for the failure. Docker logs also help you to monitor the processes inside the container by live-streaming the process details.

Docker provides us with logging mechanisms that can be used to perform debugging at the daemon as well as container level. In this article, we will discuss how to display the container logs and tail Docker logs to get only the specific lines. You can check out our complete free Docker tutorial.

You can use the Docker start command to startup containers that are stopped. You can use it to start one or more than one stopped container simultaneously. The Docker container start command will start the container and run it in the background. This will start all the processes running inside the container. This is different from the Docker run command which is used to create a new container. When we execute the run command on an image, it will pull the image, create a new container, and start it automatically. However, you can only invoke the Docker start command on containers that have already been created before.

Docker allows us to use the Docker rm and Docker stop commands to remove or stop one or more containers. However, if you want to stop and remove all the containers simultaneously, you can combine sub-commands to list all containers with the Docker stop and remove commands. Moreover, we can only remove those containers that are not actively running in our host machine.

Hence, it’s very necessary to stop all the containers before we try to remove them. We can either use the force option along with the Docker rm command to remove all containers forcefully or first stop all Docker containers and then remove them. We can also use the Docker kill command along with a sub-command to kill all the containers simultaneously.

We can use the Docker commit command to commit changes to Docker containers. Consider the following situation. When you want to run an application inside Docker containers, you might have to install packages and dependencies inside the container. Initially, you can use Dockerfile instructions to install these packages directly. However, once you have created a container, it’s not possible to keep making changes inside the Dockerfile every time you want to install something inside the container.

Also, as soon as you exit the container, all the changes inside it are lost immediately. So, you will have to go through the same process again and again. Hence, if you want the changes to persist, you can use the Docker commit command. The commit command will save any changes you make to the container and create a new image layer on top of it.

In Kubernetes, cluster capacity planning is critical to avoid overprovisioned or underprovisioned infrastructure. IT admins need a reliable and cost-effective way to maintain operational clusters and pods in high-load situations and to scale infrastructure automatically to meet resource requirements.

You can use the Docker container create command to start a container from an image. However, the container create command only creates a writable container layer over the image. Simply put, it creates a container instance but does not start a container. The container create command is almost similar to “docker run -d” with the exception that it never starts a container. You can then use the “docker start” command to start the container whenever you want.

This command is useful when you just want to set up the configuration of the container beforehand so that it is ready when you want to start the container. On running the container create command, the status of the container is created.

You can use the Docker Exec Command to execute commands inside running Docker containers. If you already have a Docker container running and you want to execute an executable command inside it, you can use the Docker exec command. However, the only constraint is that the target container’s primary process (PID = 1) should be running.

Suppose you have an Ubuntu container running in the background. And you want to create a file inside the container but you don’t have access to the bash of the container. In such a case, you can use the Docker exec command to run a touch command inside the container. This will create your new file.

You can use the Docker container rm or Docker rm command to remove or delete Docker containers. However, before you remove a container, you need to make sure that the container is not actively running. You can stop the containers using the Docker stop command before removing the containers. Another workaround is that you can use the –force option to forcefully remove containers. If you want to delete or remove all containers together, you can use a sub-command to list all container IDs along with the Docker rm command.