# Docker Development

This guide focuses on setting up a development environment for OpenAlgo  using Docker.

{% embed url="<https://www.youtube.com/watch?v=ixIJypG9oeg>" %}

### Prerequisites

* Docker Engine
* Docker Compose
* Git

## Essential .env Changes for Docker Setup&#x20;

### 1. Flask Host Configuration

```bash
# Change from 127.0.0.1 to 0.0.0.0 to allow external connections
FLASK_HOST_IP='0.0.0.0'  # Required for Docker
FLASK_PORT='5000'
```

### 2. WebSocket Configuration

```bash
# WebSocket server must bind to 0.0.0.0 inside Docker
WEBSOCKET_HOST='0.0.0.0'  # Required for Docker
WEBSOCKET_PORT='8765'
WEBSOCKET_URL='ws://localhost:8765'  # URL for clients connecting from host
```

### 3. ZeroMQ Configuration

```bash
# ZMQ must also bind to 0.0.0.0 for internal communication
ZMQ_HOST='0.0.0.0'  # Required for Docker
ZMQ_PORT='5555'
```

### Summary of Changes

#### From (Local Development):

```bash
FLASK_HOST_IP='127.0.0.1'
WEBSOCKET_HOST='127.0.0.1'
ZMQ_HOST='127.0.0.1'
```

#### To (Docker):

```bash
FLASK_HOST_IP='0.0.0.0'
WEBSOCKET_HOST='0.0.0.0'
ZMQ_HOST='0.0.0.0'
```

### Why These Changes?

1. **0.0.0.0 vs 127.0.0.1**:
   * `127.0.0.1` only allows connections from within the container
   * `0.0.0.0` allows connections from outside the container (host machine)
2. **WEBSOCKET\_URL**:
   * Remains as `ws://localhost:8765` because this is the URL clients use from the host machine
   * Docker maps the container's port to the host's localhost
3. **No other changes needed**:
   * All other settings (API keys, database URLs, etc.) remain the same
   * The docker-compose.yaml already maps the ports correctly

###

### Files Required

**1. Dockerfile**

```bash
FROM python:3.11-slim

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Install system dependencies
RUN apt-get update \
    && apt-get install -y --no-install-recommends gcc python3-dev libpq-dev \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements-nginx.txt .
RUN pip install --no-cache-dir -r requirements-nginx.txt
RUN pip install gunicorn eventlet>=0.24.1


# Copy project files
COPY . .

# Create directories and set permissions
RUN mkdir -p db logs && \
    chmod -R 777 db logs

# Command to run the application
CMD ["gunicorn", \
     "--bind", "0.0.0.0:5000", \
     "--worker-class", "eventlet", \
     "--workers", "1", \
     "--reload", \
     "--log-level", "debug", \
     "--access-logfile", "-", \
     "--error-logfile", "-", \
     "app:app"]
```

**2. docker-compose.yml**

```yaml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
      - ./db:/app/db
    env_file:
      - .env
    environment:
      - FLASK_DEBUG=True
      - FLASK_ENV=development
      - DATABASE_URL=sqlite:///db/openalgo.db
    restart: unless-stopped
```

**3. .dockerignore**

```
**/__pycache__
**/*.pyc
**/*.pyo
**/*.pyd
.Python
env/
venv/
.env*
!.env.example
*.sqlite
.git
.gitignore
.docker
Dockerfile
README.md
*.sock
```

### Quick Start

1. **Create Environment File:**

   Copy `.sample.env` to `.env`:

   ```bash
   cp .sample.env .env
   ```
2. **Build and Start:**

   ```bash
   docker-compose up --build
   ```
3. **View Logs:**

   ```bash
   docker-compose logs -f
   ```

### Development Features

* Hot reload enabled (code changes reflect immediately)
* Debug mode active
* Console logging
* Port 5000 exposed
* Volume mounting for live code updates

### Common Commands

```bash
# Start development server
docker-compose up

# Start in detached mode
docker-compose up -d

# View logs
docker-compose logs -f

# Stop containers
docker-compose down

# Rebuild after dependency changes
docker-compose up --build

# Enter container shell
docker-compose exec web bash

# Check container status
docker-compose ps
```

### Directory Structure

```
openalgo/
├── Dockerfile
├── docker-compose.yml
├── .dockerignore
├── .env
├── app.py
├── requirements-nginx.txt
└── db/
    └── openalgo.db
```

### Development Tips

1. **Live Reload:**
   * Code changes will automatically reload
   * Check logs for errors after changes
2. **Database Access:**
   * SQLite database persists in ./db directory
   * Can be accessed from both host and container
3. **Debugging:**
   * Logs are printed to console
   * Debug mode enables detailed error pages
4. **Dependencies:**
   * Add new packages to requirements-nginx.txt
   * Rebuild container after adding dependencies:

     ```bash
     docker-compose up --build
     ```

### Troubleshooting

1. **Port Already In Use:**

   ```bash
   # Check what's using port 5000
   sudo lsof -i :5000

   # Stop the container and restart
   docker-compose down
   docker-compose up
   ```
2. **Database Issues:**

   ```bash
   # Fix permissions if needed
   chmod -R 777 db/
   ```
3. **Container Won't Start:**

   ```bash
   # Check logs
   docker-compose logs

   # Remove container and try again
   docker-compose down
   docker-compose up --build
   ```
4. **Package Installation Issues:**

   ```bash
   # Rebuild without cache
   docker-compose build --no-cache
   docker-compose up
   ```

### Note

This configuration is optimized for development. For production deployment, additional security measures and optimizations would be necessary.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.openalgo.in/installation-guidelines/getting-started/docker-development.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
