Docker and Devops

​

Legacy workflow vs. Docker-enabled workflow

​

What is a Dockerfile, image, and container?

• Dockerfile: A plain-text file with step-by-step instructions to assemble an image (base OS, libraries, language runtimes, app code, environment variables, and startup commands). See Dockerfile reference: https://docs.docker.com/engine/reference/builder/
• Image: An immutable, versioned snapshot built from a Dockerfile. An image contains everything needed to run the application.
• Container: A runtime instance of an image. Containers run on any host with a compatible container runtime (e.g., the Docker Engine).

​

Example: Minimal Dockerfile

# Use an official Node.js runtime as a parent image
FROM node:18-alpine

# Set working directory and copy package manifest for dependency install
WORKDIR /app
COPY package.json package-lock.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application source code
COPY . .

# Set environment variables and expose port
ENV NODE_ENV=production
EXPOSE 3000

# Default command to run the application
CMD ["node", "server.js"]

docker build -t my-app:1.0 .
docker run -p 3000:3000 my-app:1.0

​

How Docker improves DevOps practices

• Reproducibility: Developers define the exact environment in a Dockerfile, producing consistent images for all environments.
• Reduced configuration drift: Hosts no longer require manual runtime installs or ad-hoc configuration to match developers’ setups.
• Faster troubleshooting: When an issue appears, developers and ops can run the exact same image to reproduce and diagnose problems.
• CI/CD integration: Images can be built, scanned, and published as immutable artifacts in CI pipelines, simplifying rollbacks and deployments.
• Portability: Images run wherever a compatible container runtime exists — local machines, on-prem servers, and cloud platforms.

​

Practical collaboration flow

1. Developer writes code and defines build/runtime in a Dockerfile.
2. Developer builds and tests the image locally.
3. CI pipeline builds the image, runs tests, scans for vulnerabilities, and publishes the image to a registry.
4. Operations pulls the same image and runs it on production hosts or orchestrators (Kubernetes, ECS, etc.).
5. Monitoring, logging, and deployment automation operate on consistent images, simplifying incident response and rollbacks.

​

Considerations and best practices

• Keep images small and focused to reduce attack surface and speed up CI/CD pipelines.
• Use multi-stage builds to separate build-time and runtime dependencies.
• Tag images with semantic versions and use immutable tags in production deployments.
• Scan images for vulnerabilities and enforce security policies in CI.
• Use environment variables and secrets management (not baked into images) for runtime configuration.

​

Links and references

• Docker: https://www.docker.com/
• Dockerfile reference: https://docs.docker.com/engine/reference/builder/
• Docker Engine: https://docs.docker.com/engine/
• Kubernetes documentation: https://kubernetes.io/docs/