• WordPress
  • cPanel
  • Softaculous
  • KVM Virtualization
  • Vmware Virtualization
  • Proxmox
Monday, May 12, 2025
LinuxBoost
  • Home
  • Almalinux
  • CentOS
  • Debian
  • Fedora
  • Ubuntu
  • Red Hat Enterprise Linux
  • Rocky Linux
  • OpenSUSE
  • Arch Linux
  • Oracle Linux
No Result
View All Result
LinuxBoost
  • Home
  • Almalinux
  • CentOS
  • Debian
  • Fedora
  • Ubuntu
  • Red Hat Enterprise Linux
  • Rocky Linux
  • OpenSUSE
  • Arch Linux
  • Oracle Linux
LinuxBoost
  • Home
  • Almalinux
  • CentOS
  • Debian
  • Fedora
  • Ubuntu
  • Red Hat Enterprise Linux
  • Rocky Linux
  • OpenSUSE
  • Arch Linux
  • Oracle Linux

How to deploy and manage containerized applications on Debian with Docker and Kubernetes

in Debian, Linux OS
How to deploy and manage containerized applications on Debian with Docker and Kubernetes

Introduction

Containerization has become an essential part of modern software development. It allows developers to isolate applications and dependencies, making it easier to deploy and manage them. Docker is a popular containerization platform that has revolutionized the way we develop, test, and deploy applications. Kubernetes, on the other hand, is a container orchestration platform that automates the deployment, scaling, and management of containerized applications. In this blog post, we will discuss how to deploy and manage containerized applications on Debian with Docker and Kubernetes.

Prerequisites

Before we get started, make sure you have the following installed on your system:

  • Docker
  • Kubernetes

You can install Docker and Kubernetes by following the official documentation.

Step 1: Create a Dockerfile

The first step in deploying a containerized application is to create a Dockerfile. A Dockerfile is a script that contains instructions for building a Docker image. Here is an example Dockerfile:

# Use an official Python runtime as a parent image
FROM python:3.6-slim

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# Make port 80 available to the world outside this container
EXPOSE 80

# Define environment variable
ENV NAME World

# Run app.py when the container launches
CMD ["python", "app.py"]

This Dockerfile uses the official Python runtime as a parent image and copies the current directory contents into the container at /app. It then installs any needed packages specified in requirements.txt, exposes port 80, defines an environment variable, and runs app.py when the container launches.

Step 2: Build the Docker image

Once you have created the Dockerfile, the next step is to build the Docker image. To build the Docker image, navigate to the directory where the Dockerfile is located and run the following command:

docker build -t myimage .

This command builds the Docker image with the tag “myimage” and the current directory (.) as the build context.

Step 3: Push the Docker image to a registry

After you have built the Docker image, the next step is to push the Docker image to a registry. A registry is a place where you can store and share Docker images. There are several public and private Docker registries available, including Docker Hub, Google Container Registry, and Amazon Elastic Container Registry.

To push the Docker image to a registry, you will need to tag the image with the registry’s URL and your Docker ID. For example, if you want to push the Docker image to Docker Hub, you would tag the image with the following command:

docker tag myimage username/myimage:latest

Replace “username” with your Docker ID and “myimage” with the name of your Docker image. The “:latest” tag specifies the version of the Docker image.

To push the Docker image to Docker Hub, run the following command:

docker push username/myimage:latest

Step 4: Deploy the Docker image to Kubernetes

Once you have pushed the Docker image to a registry, the next step is to deploy the Docker image to Kubernetes. Kubernetes uses a YAML file to define a deployment. Here is an example YAML file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  labels:
    app: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp

Step 5: Deploy the Docker image to Kubernetes (continued)

The YAML file above defines a deployment named “myapp” with three replicas. The deployment uses the Docker image tagged as “username/myimage:latest” that we pushed to the Docker registry in the previous step. The deployment also defines a label selector that matches the label “app: myapp”. The label selector is used to ensure that only the pods with the correct labels are managed by the deployment.

To deploy the Docker image to Kubernetes, save the YAML file as “myapp-deployment.yaml” and run the following command:

kubectl apply -f myapp-deployment.yaml

This command creates a deployment with the settings defined in the YAML file.

Step 6: Expose the deployment

After you have deployed the Docker image to Kubernetes, the next step is to expose the deployment so that it can be accessed from outside the Kubernetes cluster. To expose the deployment, you can create a Kubernetes Service. A Service is an abstraction that defines a logical set of Pods and a policy by which to access them.

Here is an example YAML file for creating a Kubernetes Service:

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

The YAML file above defines a Service named “myapp-service” that selects Pods with the label “app: myapp”. The Service exposes port 80 and uses a LoadBalancer to distribute traffic to the Pods.

To create the Kubernetes Service, save the YAML file as “myapp-service.yaml” and run the following command:

kubectl apply -f myapp-service.yaml

This command creates a Service with the settings defined in the YAML file.

Step 6: Access the application

After you have exposed the deployment with a Kubernetes Service, the final step is to access the application. To access the application, you can use the external IP address of the Service. To get the external IP address of the Service, run the following command:

kubectl get services myapp-service

This command returns the external IP address of the Service.

Conclusion

In this blog post, we discussed how to deploy and manage containerized applications on Debian with Docker and Kubernetes. We covered how to create a Dockerfile, build a Docker image, push the Docker image to a registry, deploy the Docker image to Kubernetes, expose the deployment, and access the application. By following these steps, you can easily deploy and manage containerized applications on Debian with Docker and Kubernetes.

ShareTweet
Previous Post

How to set up a web server on Debian using Nginx

Next Post

How to monitor system resources and performance in Debian using tools like top, htop, and sar

Related Posts

How to Install Tomcat on Rocky Linux

How to Install Apache Tomcat on Rocky Linux

How to Set up NTP Server on Rocky Linux

How to Set up NTP Server on Rocky Linux

How to Install Bacula Backup Server on Rocky Linux

How to Install Bacula Backup Server on Rocky Linux

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Golden Host VPS
  • Privacy Policy
  • Terms and Conditions
  • About Us
  • Contact Us

Copyright © 2023 linuxboost.com All Rights Reserved.

  • Privacy Policy
  • Terms and Conditions
  • About Us
  • Contact Us

Copyright © 2023 linuxboost.com All Rights Reserved.