1  ---
  2  title: "Docker"
  3  id: docker
  4  slug: "/docker"
  5  description: "Learn how to deploy your Haystack pipelines through Docker starting from the basic Docker container to a complex application using Hayhooks."
  6  ---
  7  
  8  # Docker
  9  
 10  Learn how to deploy your Haystack pipelines through Docker starting from the basic Docker container to a complex application using Hayhooks.
 11  
 12  ## Running Haystack in Docker
 13  
 14  The most basic form of Haystack deployment happens through Docker containers. Becoming familiar with running and customizing Haystack Docker images is useful as they form the basis for more advanced deployment.
 15  
 16  Haystack releases are officially distributed through the [`deepset/haystack`](https://hub.docker.com/r/deepset/haystack) Docker image. Haystack images come in different flavors depending on the specific components they ship and the Haystack version.
 17  
 18  :::info
 19  At the moment, the only flavor available for Haystack is `base`, which ships exactly what you would get by installing Haystack locally with `pip install haystack-ai`.
 20  :::
 21  
 22  You can pull a specific Haystack flavor using Docker tags: for example, to pull the image containing Haystack `2.12.1`, you can run the command:
 23  
 24  ```shell
 25  docker pull deepset/haystack:base-v2.12.1
 26  ```
 27  
 28  Although the `base` flavor is meant to be customized, it can also be used to quickly run Haystack scripts locally without the need to set up a Python environment and its dependencies. For example, this is how you would print Haystack’s version running a Docker container:
 29  
 30  ```shell
 31  docker run -it --rm deepset/haystack:base-v2.12.1 python -c"from haystack.version import __version__; print(__version__)"
 32  ```
 33  
 34  ## Customizing the Haystack Docker Image
 35  
 36  Chances are your application will be more complex than a simple script, and you’ll need to install additional dependencies inside the Docker image along with Haystack.
 37  
 38  For example, you might want to run a simple indexing pipeline using [Chroma](../../document-stores/chromadocumentstore.mdx) as your Document Store using a Docker container. The `base` image only contains a basic install of Haystack, but you need to install the Chroma integration (`chroma-haystack`) package additionally. The best approach would be to create a custom Docker image shipping the extra dependency.
 39  
 40  Assuming you have a `main.py` script in your current folder, the Dockerfile would look like this:
 41  
 42  ```shell
 43  FROM deepset/haystack:base-v2.12.1
 44  
 45  RUN pip install chroma-haystack
 46  
 47  COPY ./main.py /usr/src/myapp/main.py
 48  
 49  ENTRYPOINT ["python", "/usr/src/myapp/main.py"]
 50  ```
 51  
 52  Then you can create your custom Haystack image with:
 53  
 54  ```shell
 55  docker build . -t my-haystack-image
 56  ```
 57  
 58  ## Complex Application with Docker Compose
 59  
 60  A Haystack application running in Docker can go pretty far: with an internet connection, the container can reach external services providing vector databases, inference endpoints, and observability features.
 61  
 62  Still, you might want to orchestrate additional services for your Haystack container locally, for example, to reduce costs or increase performance. When your application runtime depends on more than one Docker container, [Docker Compose](https://docs.docker.com/compose/) is a great tool to keep everything together.
 63  
 64  As an example, let’s say your application wraps two pipelines: one to _index_ documents into a Qdrant instance and the other to _query_ those documents at a later time. This setup would require two Docker containers: one to run the pipelines as REST APIs using [Hayhooks](../hayhooks.mdx) and a second to run a Qdrant instance. For more information on configuring Hayhooks using Docker Compose, see the [official Hayhooks documentation](https://deepset-ai.github.io/hayhooks/getting-started/quick-start-docker/).
 65  
 66  For building the Hayhooks image, we can easily customize the base image of one of the latest versions of Hayhooks, adding required dependencies required by [`QdrantDocumentStore`](../../document-stores/qdrant-document-store.mdx). The Dockerfile would look like this:
 67  
 68  ```dockerfile Dockerfile
 69  FROM deepset/hayhooks:v1.16.0
 70  
 71  RUN pip install qdrant-haystack sentence-transformers
 72  
 73  CMD ["hayhooks", "run", "--host", "0.0.0.0"]
 74  
 75  ```
 76  
 77  We wouldn’t need to customize Qdrant, so their official Docker image would work perfectly. The `docker-compose.yml` file would then look like this:
 78  
 79  ```yaml
 80  services:
 81    qdrant:
 82      image: qdrant/qdrant:latest
 83      restart: always
 84      container_name: qdrant
 85      ports:
 86        - 6333:6333
 87        - 6334:6334
 88      expose:
 89        - 6333
 90        - 6334
 91        - 6335
 92      configs:
 93        - source: qdrant_config
 94          target: /qdrant/config/production.yaml
 95      volumes:
 96        - ./qdrant_data:/qdrant_data
 97  
 98    hayhooks:
 99      build: . # Build from local Dockerfile
100      container_name: hayhooks
101      ports:
102        - "1416:1416"
103      volumes:
104        - ./pipelines:/pipelines
105      environment:
106        - HAYHOOKS_PIPELINES_DIR=/pipelines
107        - LOG=DEBUG
108      depends_on:
109        - qdrant
110  
111  configs:
112    qdrant_config:
113      content: |
114        log_level: INFO
115  ```
116  
117  For a functional example of a Docker Compose deployment, check out the [“RAG indexing and querying with Elasticsearch”](https://github.com/deepset-ai/hayhooks/tree/main/examples/rag_indexing_query) example from GitHub.