Docker: How It Saved My Jekyll Website From Dependency Hell (A Kitchen Story)

Ever tried to set up a Jekyll website locally? If you have, you might have encountered the same frustrating experience I did. But before I share my dependency nightmare, let me explain Docker through something we all understand: a kitchen.

Understanding Docker Through Your Kitchen

Imagine you’re a chef (developer) working in different kitchens (computers). Each kitchen has its own setup, different brands of ingredients (dependencies), and various cooking tools (software versions). Sometimes, recipes (applications) that work perfectly in one kitchen fail in another because the ingredients or tools are slightly different.

Docker Images: The Perfect Recipe Kit

A Docker image is like a perfectly prepared recipe kit that contains:

• The exact ingredients in precise amounts (dependencies)
• Specific brands of ingredients (software versions)
• Required cooking tools (system utilities)
• Step-by-step instructions (configuration)
• Even the right cooking environment (operating system)

Just like a meal kit ensures you can recreate a dish exactly as intended, regardless of your kitchen setup, a Docker image ensures your application runs exactly as intended, regardless of the computer.

Docker Containers: Your Private Kitchen Space

When you use a Docker image, you create what’s called a container. Think of it as getting your own private kitchen space within the main kitchen:

• It has all the ingredients and tools from your recipe kit
• It’s completely separate from the main kitchen (isolation)
• You can’t accidentally mix up ingredients with other recipes
• If you make a mess, it doesn’t affect the main kitchen

My Jekyll Dependency Hell

Now, back to my Jekyll story. There I was, trying to set up a Jekyll website, essentially attempting to prepare a complex recipe in my main kitchen. The error messages were like a never-ending cascade:

ERROR:  Error installing jekyll:
    The last version of nokogiri (1.13.0) that supports your Ruby & RubyGems was 1.11.7.
    Try installing it with `gem install nokogiri -v 1.11.7`
    nokogiri requires Ruby version >= 2.5, < 3.1.dev.

It was like trying to make a recipe where:

• The flour (Ruby) was too old
• The baking powder (gems) wouldn’t work with this flour
• Every time I fixed one ingredient, another would become incompatible

Enter Docker: The Perfect Kitchen Solution

Docker solved my problems by giving me a perfect, pre-configured kitchen space. Instead of installing ingredients and tools in my main kitchen, I got a complete cooking station where everything just worked.

The Docker Solution

Setting up Jekyll with Docker was like getting a professional kitchen in a box. All I needed was this simple recipe (configuration file):

services:
  jekyll:
    image: bretfisher/jekyll-serve
    volumes:
      - .:/site
    ports:
      - "4000:4000"

This configuration:

• Uses a pre-configured kitchen (image) with all the right ingredients
• Connects my recipes (local files) to the kitchen
• Makes the finished dish (website) available to taste (view in browser)

Why Docker Changed Everything

Just like having a dedicated cooking space with exactly the right ingredients and tools, Docker provides:

• Perfect isolation (no cross-contamination with other recipes)
• Consistency (same results every time)
• Portability (works in any kitchen)
• Easy cleanup (just close the container)

For my Jekyll site, this meant:

• No more Ruby version conflicts (wrong flour problems)
• No more gem dependency issues (incompatible ingredients)
• No more system-specific configuration problems (kitchen equipment issues)
• A setup that works identically on any computer (same recipe, same results)

The Bigger Picture

While my Jekyll story is just one example, Docker’s kitchen-like isolation works for any development scenario. Whether you’re running a database (preparing a complex sauce), a web application (cooking a full meal), or a development environment (setting up a complete kitchen), Docker ensures everything stays organized and works consistently.

Now, whenever I start a new project, I look for Docker solutions first. The time saved and frustration avoided make it well worth the initial learning curve.

Good development isn’t just about writing code—it’s about creating reliable, reproducible environments where that code can run consistently. Just like a professional kitchen ensures consistent food quality, Docker ensures consistent application performance, and my Jekyll site is living proof.