如何编辑Docker镜像源码并重建镜像以添加日志输出？

Hey there! Let’s walk through exactly how to tackle this—from tracking down the image’s source to rebuilding it with your log changes.

Step 1: Locate the Image's Source Code or Build Context #

First, you need the original files used to build the image; this is called the build context (usually a folder with a Dockerfile and the app’s source code). Here’s how to find it:

• For public images (e.g., Nginx, Node.js): Head to the image’s Docker Hub listing. Most official images include a link to their source repository (with Dockerfile and app code) directly in the description. If it’s a community-maintained image, check the repo linked there too.
• For custom/internal images: Reach out to the team or person who originally built the image—they almost certainly have the original build context saved somewhere (it’s best practice to keep these files under version control like Git).
• Last resort: Reverse-engineer the image (not ideal): If you can’t get the original context, you can export the image’s filesystem to inspect its contents:
  1. Save the image to a tar file: docker save <your-image-name> -o image.tar
  2. Extract the tar file: mkdir image-content && tar -xf image.tar -C image-content
  3. Browse the extracted folders to find the app’s code or binaries. Note: This won’t give you the original Dockerfile or build steps, so rebuilding will require writing a new Dockerfile from scratch.

Step 2: Modify the Source Code to Add Logs #

Once you have the source code, add log statements to the parts of the app you want to track. The exact method depends on the language:

• Python: Use the built-in logging module to output structured logs to stdout/stderr (Docker automatically collects these):

  import logging
  logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
  
  def main():
      logging.info("Application started successfully")
      # Your existing code here
      logging.info("Processing finished, exiting gracefully")
  

• Go: Use the log package to write to stdout:

  package main
  
  import "log"
  
  func main() {
      log.Println("App initialized")
      // Rest of your code
      log.Println("Shutting down application")
  }
  

• Binary apps (e.g., Nginx): If you’re working with a pre-built binary, modify its configuration to enable logs. For Nginx, update the nginx.conf to send access/error logs to stdout:

  access_log /dev/stdout;
  error_log /dev/stderr;
  

Step 3: Rebuild the Docker Image #

With your modified code/config ready, rebuild the image using the original Dockerfile (or your custom one if you reverse-engineered):

1. Navigate to the build context folder (where the Dockerfile lives).
2. Run the build command: docker build -t <new-image-tag> .
   • Replace <new-image-tag> with a name like my-app:log-enabled to distinguish it from the original.

Step 4: Test the Log Output #

Run a container from your new image and verify the logs:

1. Start the container: docker run <new-image-tag>
2. If the logs don’t show up in your terminal, fetch them with: docker logs <container-id>
   • Get the <container-id> by running docker ps (or docker ps -a if the container stopped).

Pro Tips for Logging in Docker #

• Always log to stdout/stderr instead of files—Docker’s logging driver automatically captures these, making it easy to view logs with docker logs or ship them to tools like ELK or Promtail.
• If you can’t modify the app’s code (e.g., closed-source binary), add a wrapper script to log startup/shutdown events. Create a start.sh file:

  #!/bin/bash
  echo "$(date '+%Y-%m-%d %H:%M:%S'): Starting application..."
  exec /path/to/your/app "$@"
  

  Then update the Dockerfile to use this script as the entrypoint:

  COPY start.sh /start.sh
  RUN chmod +x /start.sh
  ENTRYPOINT ["/start.sh"]
  

  The exec command ensures the app receives signals (like SIGTERM for shutdown) properly.

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