prefect.yaml

deployment.py

src

python
# src/deployment.py
from prefect import serve
from flow.test_flow import cat_fact_flow

if __name__ == "__main__":
    cat_fact_flow.deploy(
        name="cat-fact-deployment",
        work_pool_name="cat-facts-pool",
        image="cat-facts-image:latest"
    )

yaml
version: '3.8'
services:
  prefect_server:
    build:
      context: .
      dockerfile: Dockerfile.prefect_server
    ports:
      - "4200:4200"
    environment:
      - PREFECT_SERVER_API_HOST=0.0.0.0
      - PREFECT_SERVER_API_PORT=4200

  prefect_worker:
    build:
      context: .
      dockerfile: Dockerfile.prefect_worker
    environment:
      - PREFECT_API_URL=<http://prefect_server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    depends_on:
      - prefect_server

dockerfile
FROM prefecthq/prefect:2-python3.10

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

# Add httpx to requirements.txt or install it here
RUN pip install httpx

CMD ["prefect", "worker", "start", "--pool", "cat-facts-pool", "--type", "docker"]

Dockerfile.flow

dockerfile
FROM prefecthq/prefect:2-python3.10

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt
RUN pip install httpx

COPY flow/ /app/flow/

CMD ["python", "flow/test_flow.py"]

prefect>=3.0.0
httpx

bash
prefect work-pool create cat-facts-pool --type docker

bash
docker-compose up -d

bash
docker build -t cat-facts-image:latest -f Dockerfile.flow .

bash
python deployment.py

bash
prefect deployment run cat-fact-flow/cat-fact-deployment

prefect.yaml

.deploy()

deployments.py

python
# src/deployments.py
from prefect import serve
from flow.test_flow import cat_fact_flow
# Import other flows
from flow.other_flow import other_flow
from flow.another_flow import another_flow

def deploy_all():
    # Cat Facts Deployment
    cat_fact_flow.deploy(
        name="cat-fact-deployment",
        work_pool_name="cat-facts-pool",
        image="cat-facts-image:latest",
        schedule={"interval": "1 hour"}  # Optional: Add schedule
    )

    # Other Flow Deployment
    other_flow.deploy(
        name="other-deployment",
        work_pool_name="other-pool",
        image="other-image:latest",
        schedule={"cron": "0 0 * * *"}  # Optional: Add schedule
    )

    # Another Flow Deployment
    another_flow.deploy(
        name="another-deployment",
        work_pool_name="another-pool",
        image="another-image:latest"
    )

if __name__ == "__main__":
    deploy_all()

deployments

src/
├── deployments/
│   ├── __init__.py
│   ├── cat_facts.py
│   ├── other_flow.py
│   └── another_flow.py
├── flow/
│   ├── test_flow.py
│   ├── other_flow.py
│   └── another_flow.py
└── deploy_all.py

python
# src/deployments/cat_facts.py
from prefect import serve
from flow.test_flow import cat_fact_flow

def deploy():
    cat_fact_flow.deploy(
        name="cat-fact-deployment",
        work_pool_name="cat-facts-pool",
        image="cat-facts-image:latest"
    )

if __name__ == "__main__":
    deploy()

python
# src/deployments/other_flow.py
from prefect import serve
from flow.other_flow import other_flow

def deploy():
    other_flow.deploy(
        name="other-deployment",
        work_pool_name="other-pool",
        image="other-image:latest"
    )

if __name__ == "__main__":
    deploy()

python
# src/deploy_all.py
from deployments import cat_facts, other_flow, another_flow

if __name__ == "__main__":
    cat_facts.deploy()
    other_flow.deploy()
    another_flow.deploy()

dockerfile
# Dockerfile.flow
FROM prefecthq/prefect:2-python3.10

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy all flow directories
COPY flow/ /app/flow/

# The specific flow to run will be determined by the deployment

docker-compose.yml

yaml
version: '3.8'
services:
  prefect_server:
    build:
      context: .
      dockerfile: Dockerfile.prefect_server
    ports:
      - "4200:4200"
    environment:
      - PREFECT_SERVER_API_HOST=0.0.0.0
      - PREFECT_SERVER_API_PORT=4200

  cat_facts_worker:
    build:
      context: .
      dockerfile: Dockerfile.prefect_worker
    environment:
      - PREFECT_API_URL=<http://prefect_server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: ["prefect", "worker", "start", "--pool", "cat-facts-pool", "--type", "docker"]
    depends_on:
      - prefect_server

  other_worker:
    build:
      context: .
      dockerfile: Dockerfile.prefect_worker
    environment:
      - PREFECT_API_URL=<http://prefect_server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: ["prefect", "worker", "start", "--pool", "other-pool", "--type", "docker"]
    depends_on:
      - prefect_server

bash
prefect work-pool create cat-facts-pool --type docker
prefect work-pool create other-pool --type docker

bash
docker build -t cat-facts-image:latest -f Dockerfile.flow .
docker build -t other-image:latest -f Dockerfile.flow .

bash
python deploy_all.py

bash
python deployments/cat_facts.py
python deployments/other_flow.py

bash
docker-compose up -d

bash
prefect deployment run 'cat-fact-flow/cat-fact-deployment'
prefect deployment run 'other-flow/other-deployment'

yaml
version: '3.8'
services:
  prefect_server:
    build:
      context: .
      dockerfile: Dockerfile.prefect_server
    ports:
      - "4200:4200"
    environment:
      - PREFECT_SERVER_API_HOST=0.0.0.0
      - PREFECT_SERVER_API_PORT=4200

  prefect_worker:
    build:
      context: .
      dockerfile: Dockerfile.prefect_worker
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock  # Give Docker access to worker
      - ./:/app  # Mount your code
    environment:
      - PREFECT_API_URL=<http://prefect_server:4200/api>
    depends_on:
      - prefect_server

deployment.py

python
from prefect import flow
from flow.test_flow import cat_fact_flow

if __name__ == "__main__":
    cat_fact_flow.deploy(
        name="cat-fact-deployment",
        work_pool_name="cat-facts-pool",
        image="cat-facts-image:latest"
    )

Dockerfile.flow

dockerfile
FROM prefecthq/prefect:2-python3.10

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt
RUN pip install httpx

COPY flow/ /app/flow/

CMD ["python", "flow/test_flow.py"]

bash
prefect work-pool create cat-facts-pool --type docker

bash
docker build -t cat-facts-image:latest -f Dockerfile.flow .

bash
docker-compose up -d

bash
python deployment.py

bash
prefect deployment run 'Cat Fact Flow/cat-fact-deployment'

bash
# To access the worker container
docker-compose exec prefect_worker bash

# To access the server container
docker-compose exec prefect_server bash

/var/run/docker.sock

Dockerfile.prefect_server

dockerfile
FROM prefecthq/prefect:2-python3.10

WORKDIR /app

# Install Docker CLI (needed for building images)
RUN apt-get update && apt-get install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release \
    && curl -fsSL <https://download.docker.com/linux/debian/gpg> | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg \
    && echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] <https://download.docker.com/linux/debian> $(lsb_release -cs) stable" > /etc/apt/sources.list.d/docker.list \
    && apt-get update \
    && apt-get install -y docker-ce-cli

# Copy your application files
COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy your application code
COPY . .

# Start the Prefect server
CMD ["prefect", "server", "start"]

yaml
version: '3.8'
services:
  prefect_server:
    build:
      context: .
      dockerfile: Dockerfile.prefect_server
    ports:
      - "4200:4200"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock  # Give Docker access
      - .:/app  # Mount your code
    environment:
      - PREFECT_SERVER_API_HOST=0.0.0.0
      - PREFECT_SERVER_API_PORT=4200

  prefect_worker:
    build:
      context: .
      dockerfile: Dockerfile.prefect_worker
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - .:/app
    environment:
      - PREFECT_API_URL=<http://prefect_server:4200/api>
    depends_on:
      - prefect_server

src/deployment.py

python
from prefect import flow
from flow.test_flow import cat_fact_flow
import subprocess

def build_and_push_image():
    """Build and push the Docker image"""
    subprocess.run(["docker", "build", "-t", "cat-facts-image:latest", "-f", "Dockerfile.flow", "."], check=True)
    # If using a registry, you would push here
    # subprocess.run(["docker", "push", "your-registry/cat-facts-image:latest"], check=True)

def deploy_flow():
    """Deploy the flow"""
    # Build the image first
    build_and_push_image()
    
    # Deploy the flow
    cat_fact_flow.deploy(
        name="cat-fact-deployment",
        work_pool_name="cat-facts-pool",
        image="cat-facts-image:latest",
        build=None  # We're handling the build separately
    )

if __name__ == "__main__":
    deploy_flow()

src/deploy_all.sh

bash
#!/bin/bash
set -e

# Create work pool if it doesn't exist
prefect work-pool create cat-facts-pool --type docker || true

# Run the deployment
python deployment.py

bash
chmod +x deploy_all.sh

.github/workflows/deploy.yml

yaml
name: Deploy Prefect Flows

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

      - name: Build and start services
        run: |
          docker-compose up -d
          # Wait for services to be ready
          sleep 30

      - name: Deploy flows
        run: |
          docker-compose exec -T prefect_server ./deploy_all.sh

bash
# Start the services
docker-compose up -d

# Execute deployment inside the container
docker-compose exec prefect_server ./deploy_all.sh

2. *Registry Authentication*: If using a private registry:

```python
# In deployment.py
import os

def build_and_push_image():
    registry = os.getenv("DOCKER_REGISTRY", "your-registry")
    image_name = f"{registry}/cat-facts-image:latest"
    
    # Login to registry (in CI/CD, this would be handled by GitHub Actions)
    subprocess.run(["docker", "login", registry, 
                   "-u", os.getenv("DOCKER_USERNAME"),
                   "-p", os.getenv("DOCKER_PASSWORD")], 
                  check=True)
    
    # Build and push
    subprocess.run(["docker", "build", "-t", image_name, "-f", "Dockerfile.flow", "."], check=True)
    subprocess.run(["docker", "push", image_name], check=True)

python
# In deployment.py
import logging

logging.basicConfig(level=<http://logging.INFO|logging.INFO>)
logger = logging.getLogger(__name__)

def deploy_flow():
    try:
        build_and_push_image()
        <http://logger.info|logger.info>("Successfully built and pushed image")
        
        cat_fact_flow.deploy(
            name="cat-fact-deployment",
            work_pool_name="cat-facts-pool",
            image="cat-facts-image:latest"
        )
        <http://logger.info|logger.info>("Successfully deployed flow")
    except Exception as e:
        logger.error(f"Deployment failed: {str(e)}")
        raise