如何用Kubectl将多镜像（Redis+Memcache+Python）合并到Pod单容器及替代方案

Hey there! Let's tackle your question about running Redis, Memcached, and Python in a single container within a Kubernetes Pod—plus alternatives to building a custom Docker image.

First, a quick note on best practices #

Before diving into solutions, it’s important to call out that running multiple processes in a single container goes against Kubernetes and container design principles. Containers are meant to run one main process each—this makes monitoring, logging, fault isolation, and resource management far easier. That said, let’s cover your options.

Option 1: Dynamically install and start processes via kubectl run (no custom image) #

You can use a base image with a package manager (like Ubuntu or Debian) and run a bash command to install all required software and start the processes directly when creating the Pod. Here’s how:

kubectl run multi-process-pod --image=ubuntu:latest --command -- /bin/bash -c "apt-get update && apt-get install -y redis-server memcached python3 && redis-server --daemonize yes && memcached -d && python3 -m http.server 8000 && tail -f /dev/null"

Breakdown of this command: #

• We use the ubuntu:latest image as our base
• Update apt packages, then install Redis, Memcached, and Python 3
• Start Redis and Memcached as background daemons
• Launch a simple Python HTTP server (replace this with your actual Python app)
• Use tail -f /dev/null to keep the container running (otherwise it would exit once all commands finish)

Downsides: #

• Slow startup: Every time the Pod restarts, you’ll re-install all software from scratch
• No persistence: Any data or configuration changes are lost when the container stops
• Poor process management: If Redis/Memcached/Python crashes, the container won’t automatically restart that specific process (only the entire container if it exits)

Option 2: Use a ConfigMap to mount a startup script #

To clean up the long command in Option 1, you can store your startup logic in a script and mount it via a ConfigMap. This makes the script easier to edit and reuse.

1. Create a startup script start-all.sh:

#!/bin/bash
set -e

# Install dependencies
apt-get update && apt-get install -y redis-server memcached python3

# Start services in the background
redis-server --daemonize yes
memcached -d

# Launch your Python application (replace with your app command)
python3 -m http.server 8000

# Keep container running
tail -f /dev/null

2. Create the ConfigMap from the script:

kubectl create configmap multi-process-script --from-file=start-all.sh

3. Run the Pod, mounting the ConfigMap and executing the script:

kubectl run multi-process-pod --image=ubuntu:latest \
  --volume name=script-volume,configMap=multi-process-script \
  --volume-mount mountPath=/scripts,volumeName=script-volume \
  --command -- /bin/bash /scripts/start-all.sh

This works the same as Option 1 but is more maintainable—you can update the script by editing the ConfigMap instead of rewriting the entire kubectl run command.

Option 3: Use a process manager like supervisord (more reliable process monitoring) #

If you need better process management (e.g., auto-restart crashed processes), you can install supervisord in the container to handle all your services.

Update your startup script (start-all.sh) to use supervisord:

#!/bin/bash
set -e

# Install dependencies and supervisord
apt-get update && apt-get install -y redis-server memcached python3 supervisor

# Create supervisord configuration
cat > /etc/supervisor/conf.d/multi-services.conf << EOF
[supervisord]
nodaemon=true

[program:redis]
command=redis-server
autorestart=true
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0

[program:memcached]
command=memcached
autorestart=true
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0

[program:python-app]
command=python3 -m http.server 8000
autorestart=true
stdout_logfile=/dev/stdout
stdout_logfile_maxbytes=0
EOF

# Start supervisord
supervisord -c /etc/supervisor/supervisord.conf

Then follow the same ConfigMap steps from Option 2 to run the Pod. supervisord will monitor all three processes, restarting any that crash, and redirect all logs to stdout (making them accessible via kubectl logs).

The Recommended Alternative: Multiple Containers in a Single Pod (Sidecar Pattern) #

While you asked for a single container, this is the Kubernetes-native best practice for running multiple services that need to work together. A Pod can have multiple containers that share the same network namespace (so they can communicate via localhost) and storage volumes.

Here’s a YAML example:

apiVersion: v1
kind: Pod
metadata:
  name: multi-service-pod
spec:
  containers:
    - name: redis
      image: redis:latest
      ports:
        - containerPort: 6379
      # Optional: Add resource limits/requests
      resources:
        requests:
          memory: "64Mi"
          cpu: "250m"
        limits:
          memory: "128Mi"
          cpu: "500m"
    - name: memcached
      image: memcached:latest
      ports:
        - containerPort: 11211
      resources:
        requests:
          memory: "64Mi"
          cpu: "250m"
        limits:
          memory: "128Mi"
          cpu: "500m"
    - name: python-app
      image: python:latest
      command: ["python3", "-m", "http.server", "8000"]
      ports:
        - containerPort: 8000
      resources:
        requests:
          memory: "128Mi"
          cpu: "500m"
        limits:
          memory: "256Mi"
          cpu: "1000m"
  # Optional: Shared volume for data between containers
  volumes:
    - name: shared-data
      emptyDir: {}

Create the Pod with:

kubectl apply -f multi-service-pod.yaml

Why this is better: #

• Isolation: Each container runs one process, making it easier to debug, update, and scale individual services
• Monitoring: You can collect logs and metrics for each service separately
• Reliability: If one service crashes, only its container restarts (not the entire Pod)
• No custom images: Use official, maintained images for Redis, Memcached, and Python

内容的提问来源于stack exchange，提问作者Ramya S