Kubernetes and Docker: Deploying and Managing Containerized Apps

The steps to deploy containerized applications using Kubernetes and Docker include: 1. Build a Docker image, define the application image using Dockerfile and push it to Docker Hub. 2. Create Deployment and Service in Kubernetes to manage and expose applications. 3. Use Horizontal Pod Autoscaler to achieve dynamic scaling. 4. Debug FAQs through the kubectl command. 5. Optimize performance, define resource limits and requests, and manage configurations using Helm.

introduction

Recently I was trying to make a project that involved containerized deployment, and Kubernetes and Docker became my saviors. To be honest, when I first started to get involved in these two things, I was completely confused, but gradually, I found that they not only made my application deployment simple, but also gave me a deeper understanding of the microservice architecture. Today I will talk about how to use Kubernetes and Docker to deploy and manage containerized applications, hoping to help those friends who are still exploring.

Review of basic knowledge

To figure out Kubernetes and Docker, we have to start with containers. A container can be regarded as a lightweight virtual machine, but it is more efficient than a virtual machine because it runs directly on the host's kernel. Docker is the most popular containerized platform at present, allowing developers to package applications and their dependencies into a mirror and then run in any Docker-enabled environment.

Kubernetes, referred to as K8s, is an open source container orchestration system. It manages and schedules these containers to ensure they run efficiently in the cluster. K8s allows developers to easily expand, update and maintain applications.

Core concept or function analysis

What Docker does

The core of Docker is images and containers. A mirror is like a snapshot of an application, containing everything you need to run the application. The container is an instantiation of the image, which you can think of as a running application.

 # Build a simple Node.js application image FROM node:14

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "app.js"]

This Dockerfile defines a Node.js application image, which is simple and clear. You can use the docker build command to build this image and then start a container with the docker run command.

How Kubernetes works

How Kubernetes works can be illustrated in a simple metaphor: it is like a band conductor who coordinates various instruments (containers) to play beautiful music (applications). The core concepts of K8s include Pod, Service, Deployment, etc.

A Pod is the smallest scheduling unit in K8s, and a Pod can contain one or more containers. Service is used to expose the Pod's network services, while Deployment is used to manage the life cycle of the Pod, such as rolling updates and rollbacks.

 # Define a simple deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:v1
        Ports:
        - containerPort: 3000

This YAML file defines a Deployment called my-app , which creates three pods running my-app:v1 image.

Example of usage

Basic usage

To deploy an application using Docker and Kubernetes, you must first have a Docker image. You can build images with Dockerfile and push them to Docker Hub or private repository.

 # Build the image docker build -t my-app:v1.

# Push image to Docker Hub
docker push my-app:v1

Then create a Deployment and Service in Kubernetes to manage and expose the application.

 # Create a Deployment
kubectl apply -f deployment.yaml

# Create Service
kubectl apply -f service.yaml

Advanced Usage

In actual projects, you may encounter some complex needs, such as dynamically extending the Pod or implementing blue-green deployment. K8s provides Horizontal Pod Autoscaler (HPA) for automatic scaling.

 # Define an HPA
apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      targetAverageUtilization: 50

This HPA will automatically adjust the number of pods in my-app Deployment based on CPU usage.

Common Errors and Debugging Tips

Common problems when using K8s and Docker include image pull failure, Pod startup failure, network problems, etc. When debugging these problems, you can use kubectl describe and kubectl logs commands to view the details.

 # View Pod details kubectl describe pod my-app-xxxxxxxxxx-xxxxxxxx

# View Pod's log kubectl logs my-app-xxxxxxxxxx-xxxxxxx

Performance optimization and best practices

Performance optimization is a key point when using K8s and Docker. You can improve performance by optimizing image size, using resource limits and requests, and configuring Pod's scheduling policies reasonably.

 # Define resource restrictions and request resources:
  Requests:
    cpu: 100m
    memory: 128Mi
  limits:
    cpu: 500m
    memory: 512Mi

This configuration defines the resource requests and restrictions of the Pod to ensure that it does not consume too much resources.

In actual projects, I found that using Helm to manage K8s' configuration files is a good choice, which can help you better manage and reuse configurations. In addition, it is also a good habit to regularly clean unused images and pods, which can save resources.

In general, Kubernetes and Docker are powerful tools for modern application deployment and management. They not only allow developers to manage applications more flexibly, but also provide powerful expansion and maintenance capabilities. I hope this article can help you understand and use them better and go further on the road to containerization.

The above is the detailed content of Kubernetes and Docker: Deploying and Managing Containerized Apps. For more information, please follow other related articles on the PHP Chinese website!