# How to Use .gitignore with Docker and Containerized Applications

> Learn to use .gitignore with Docker and containerized apps. Exclude build artifacts cache and local overrides from version control for cleaner repositories and efficient workflows.

- Repository: [GitHub/gitignore](https://github.com/github/gitignore)
- Tags: how-to-guide
- Published: 2026-02-24

---

**Combine language-specific templates from the github/gitignore repository with Docker-specific patterns to exclude build artifacts, local compose overrides, and container cache files from version control.**

The **github/gitignore** repository provides community-curated templates for keeping repositories clean. When containerizing applications, you must layer Docker-specific exclusions—such as compose environment files and temporary build directories—atop base templates like `Python.gitignore` or `Node.gitignore` to prevent sensitive data and ephemeral artifacts from entering version control.

## Repository Structure and Template Organization

The github/gitignore repository organizes ignore patterns into three distinct categories to help you construct the right configuration for containerized projects:

- **Root templates**: Language and framework-specific files located in the repository root, including `Python.gitignore`, `Node.gitignore`, and `Go.gitignore`
- **Global folder**: Editor and IDE-specific patterns such as `Global/Vim.gitignore` or `Global/VisualStudioCode.gitignore` for tool-generated files
- **Community folder**: Specialized templates for niche tools under the `community/` directory

While the repository does not currently include a dedicated `Docker.gitignore` template in the root or `community/` folders, the recommended approach is to start with your application's language template and append container-specific patterns. Consult the [`README.md`](https://github.com/github/gitignore/blob/main/README.md) file in the repository root for guidelines on combining multiple templates.

## Essential .gitignore Patterns for Docker Projects

Containerized workflows generate files that should never be committed. Add these patterns to your `.gitignore` after your base language template:

| Pattern | What It Excludes |
|---------|------------------|
| [`docker-compose.override.yml`](https://github.com/github/gitignore/blob/main/docker-compose.override.yml) | Local development overrides containing machine-specific paths or secrets |
| `docker-compose.*.yml` | Environment-specific compose variants (e.g., [`docker-compose.prod.yml`](https://github.com/github/gitignore/blob/main/docker-compose.prod.yml) used only in CI) |
| `docker-compose.*.env` | Environment files referenced by Compose that may contain database credentials |
| `**/Dockerfile.*` | Temporary Dockerfiles generated by build scripts (keep the base `Dockerfile` versioned) |
| `tmp/` | Temporary directories created during multi-stage Docker builds |
| `build/` | Artifact directories generated inside containers |
| `.cache/` | Docker layer caches and CI pipeline dependency caches |
| `dist/` | Compiled binaries or distribution bundles produced by containerized builds |
| `*.log` | Service logs generated by applications running inside containers |
| `*.pid` | Process ID files from containerized services |

**Critical**: Do not ignore `Dockerfile` or [`docker-compose.yml`](https://github.com/github/gitignore/blob/main/docker-compose.yml) (without suffixes), as these are essential configuration files required to build and orchestrate your application.

## Practical Implementation Examples

### Python Application with Docker

Start with the official `Python.gitignore` template located in the repository root, then append container-specific exclusions:

```text

# Contents from Python.gitignore

__pycache__/
*.py[cod]
*$py.class
*.so
.Python
env/
build/
develop-eggs/
dist/
*.egg-info/

# Docker-specific additions

docker-compose.override.yml
docker-compose.*.yml
docker-compose.*.env
tmp/
.cache/
*.log
*.pid

```

### Node.js Containerized Project

For Node.js applications, combine `Node.gitignore` with patterns for container orchestration:

```text

# Contents from Node.gitignore

logs
*.log
npm-debug.log*
node_modules/
jspm_packages/
.npm
.eslintcache

# Docker exclusions

docker-compose.override.yml
docker-compose.*.env
build/
dist/
.cache/

```

### Multi-Language Monorepo

In repositories containing multiple services, place combined patterns at the root. Reference templates from `Python.gitignore`, `Node.gitignore`, or `Go.gitignore` as needed, then add global IDE settings from `Global/VisualStudioCode.gitignore` or `Global/Vim.gitignore`, followed by Docker rules:

```text

# Service-specific sections (Python, Node, Go templates)

# Global IDE settings

.vscode/
*.swp

# Docker patterns for all services

docker-compose.override.yml
docker-compose.*.yml
docker-compose.*.env
tmp/
build/
.cache/
dist/

```

## .gitignore vs. .dockerignore

While `.gitignore` prevents files from entering Git history, **`.dockerignore`** (created in your project root) controls what Docker copies into the build context. Both files use identical pattern syntax but operate at different stages:

- **`.gitignore`**: Excludes files from version control using templates from github/gitignore
- **`.dockerignore`**: Excludes files from the Docker build context, reducing image size and preventing sensitive local files from being baked into images

Commit your `.dockerignore` file to version control, but ensure it excludes the `.git` directory and local development artifacts that should not appear in container images.

## Summary

- Start with root templates like `Python.gitignore` or `Node.gitignore` from github/gitignore, then append patterns for [`docker-compose.override.yml`](https://github.com/github/gitignore/blob/main/docker-compose.override.yml), `tmp/`, and cache directories
- Reference the `Global/` folder for IDE-specific exclusions and the `community/` folder for specialized tooling templates
- Always version control your `Dockerfile`, [`docker-compose.yml`](https://github.com/github/gitignore/blob/main/docker-compose.yml), and `.dockerignore` while ignoring environment-specific variants and local override files
- Use `.dockerignore` separately to optimize container build contexts and prevent bloated images

## Frequently Asked Questions

### Should I ignore Dockerfile and docker-compose.yml in my .gitignore?

No. These are essential configuration files required to build and run your containerized application. Only ignore variants like [`docker-compose.override.yml`](https://github.com/github/gitignore/blob/main/docker-compose.override.yml) or `docker-compose.*.env` that contain local secrets or machine-specific settings.

### Where does the github/gitignore repository store Docker-specific templates?

The repository does not currently include a dedicated Docker template in the root or `community/` folders. Instead, Docker patterns are applied as additions to language-specific templates like `Python.gitignore` or `Node.gitignore` according to the guidelines in [`README.md`](https://github.com/github/gitignore/blob/main/README.md).

### What is the difference between .gitignore and .dockerignore?

`.gitignore` prevents files from being committed to Git history, while `.dockerignore` prevents files from being copied into the Docker build context. Use `.gitignore` to keep repository history clean and `.dockerignore` to reduce container image size and build time.

### How do I handle multiple docker-compose files for different environments?

Ignore environment-specific variants using patterns like `docker-compose.*.yml` and `docker-compose.*.env`, but commit the base [`docker-compose.yml`](https://github.com/github/gitignore/blob/main/docker-compose.yml). This allows developers to create local [`docker-compose.override.yml`](https://github.com/github/gitignore/blob/main/docker-compose.override.yml) files without risking exposure of sensitive configuration or local paths.