How do you manage containerized applications in a Kubernetes cluster?

Managing containerized applications in a Kubernetes cluster is a systematic task involving multiple components and resources. Below, I will outline the key steps and related Kubernetes resources to ensure efficient and stable operation of your applications.

1. Define the Configuration of Containerized Applications

First, define the basic attributes of the application container using a Dockerfile. The Dockerfile specifies all commands required to build the container image, including the operating system, dependency libraries, and environment variables.

Example: Create a simple Node.js application Dockerfile.

Dockerfile
FROM node:14
WORKDIR /app
COPY . /app
RUN npm install
EXPOSE 8080
CMD ["node", "app.js"]

2. Build and Store Container Images

The built image must be pushed to a container registry to enable any node in the Kubernetes cluster to access and deploy it.

Example: Use Docker commands to build and push the image.

bash
docker build -t my-node-app:v1 .
docker push my-node-app:v1

3. Deploy Applications Using Pods

In Kubernetes, a Pod is the fundamental deployment unit, which can contain one or more containers (typically closely related containers). Create a YAML file to define the Pod resource, specifying the required image and other configurations such as resource limits and environment variables.

Example: Create a Pod to run the previous Node.js application.

yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-node-app-pod
spec:
  containers:
  - name: my-node-app-container
    image: my-node-app:v1
    ports:
    - containerPort: 8080

4. Deploy Applications Using Deployments

While individual Pods can run the application, to improve reliability and scalability, Deployments are typically used to manage Pod replicas. A Deployment ensures that a specified number of Pod replicas remain active and supports rolling updates and rollbacks.

Example: Create a Deployment to deploy 3 replicas of the Node.js application.

yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-node-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-node-app
  template:
    metadata:
      labels:
        app: my-node-app
    spec:
      containers:
      - name: my-node-app
        image: my-node-app:v1
        ports:
        - containerPort: 8080

5. Configure Service and Ingress

To enable external access to the application, configure a Service and possibly an Ingress. A Service provides a stable IP address and DNS name, while an Ingress manages routing for external traffic to internal services.

Example: Create a Service and Ingress to provide external HTTP access for the Node.js application.

yaml
# Service
apiVersion: v1
kind: Service
metadata:
  name: my-node-app-service
spec:
  selector:
    app: my-node-app
  type: NodePort
  ports:
  - port: 8080
    targetPort: 8080
    protocol: TCP

# Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-node-app-ingress
spec:
  rules:
  - http:
      paths:
      - path: /nodeapp
        pathType: Prefix
        backend:
          service:
            name: my-node-app-service
            port:
              number: 8080

6. Monitoring and Logging

Finally, to ensure application stability and promptly identify issues, configure monitoring and log collection. Use Prometheus and Grafana for monitoring, and ELK stack or Loki for collecting and analyzing logs.

By following these steps, you can efficiently deploy, manage, and monitor your containerized applications within a Kubernetes cluster.