version: "3.9"

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    container_name: prefect-server
    environment:
      PREFECT_SERVER_API_HOST: 0.0.0.0
    command: prefect server start --host 0.0.0.0
    ports:
      - "4200:4200"
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('<http://localhost:4200/api/health>', timeout=1)"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    container_name: prefect-docker-worker
    depends_on:
      prefect-server:
        condition: service_healthy
    environment:
      # Point the worker to the local Prefect API
      PREFECT_API_URL: <http://prefect-server:4200/api>
      # Optional tuning:
      # PREFECT_WORKER_PREFETCH_SECONDS: "10"
      # PREFECT_WORKER_QUERY_SECONDS: "15"
    volumes:
      # Critical: allow the worker to create Docker containers
      - /var/run/docker.sock:/var/run/docker.sock
    # Use 'uv' to ensure the docker integration is available
    command: >
      uv run --with 'prefect[docker]'
      prefect worker start
      --pool docker-pool
    restart: on-failure

prefect work-pool create --type docker docker-pool

/var/run/docker.sock

uv run --with 'prefect[docker]'

prefect-server

PREFECT_API_URL

docker compose up -d

docker compose logs -f prefect-docker-worker

prefect worker ls

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    container_name: prefect-server
    environment:
      PREFECT_SERVER_API_HOST: 0.0.0.0
      PREFECT_UI_ENABLED: "true"
      # Explicitly tell the UI where the API lives from your browser’s perspective
      PREFECT_UI_API_URL: <http://localhost:4200/api>
    command: prefect server start --host 0.0.0.0
    ports:
      - "4200:4200"

curl -s <http://localhost:4200/api/health>

true

<http://127.0.0.1:4200/api/health>

docker compose logs -f prefect-server

/api

PREFECT_UI_API_URL

docker compose ps
  docker compose logs --tail=100 prefect-server
  curl -v <http://localhost:4200/api/health>

job_configuration

image

env

env

"true"

prefecthq/prefect:3-python3.11-uv

PREFECT_APPLY_MARK

PREFECT_JOB_EXTRA_COMMANDS

uv sync --system-site-packages

command

jsonencode

base_job_template = jsonencode({
  job_configuration = {
    image   = "prefecthq/prefect:3-python3.11-uv"
    command = "bash -lc 'uv sync --system-site-packages && prefect flow-run execute'"
    env = {
      # Any env you really need at runtime; remove if not used by your code
      PREFECT_APPLY_MARK         = "true"
      PREFECT_JOB_EXTRA_COMMANDS = "uv sync --system-site-packages"
    }
  }
})

prefect work-pool create my-docker-pool --type docker --base-job-template ./base-job-template.json

git --version

.from_source('<https://github.com/owner/repo.git>', entrypoint='path.py:flow')

from prefect.runner.storage import GitRepository
    from prefect_github import GitHubCredentials

    my_flow = flow.from_source(
      source=GitRepository(
        url="<https://github.com/owner/repo.git>",
        branch="main",
        credentials=GitHubCredentials.load("my-github-creds"),
        # optionally: directories=["flows"]   # for sparse checkout
      ),
      entrypoint="flows/my_flow.py:my_flow",
    )

credentials={"access_token": Secret.load("github-token")}

git@github.com:...

git clone <https://github.com/owner/repo.git>

export PREFECT_DEBUG_MODE=true
  export PREFECT_LOGGING_LEVEL=DEBUG
  export PREFECT_RUNNER_LOG_LEVEL=DEBUG
  prefect worker start --pool <your-pool> --type process

Failed to clone repository '<https://github.com/owner/repo.git>' with exit code 2.

directories=[...]

branch

commit_sha

.from_source(...)

prefect deploy

git --version

GitRepository

prefect worker start --pool <your-docker-pool> --type docker

uv

&&

&&

sh -c ...

&&

variables

variables

variables

resource "prefect_work_pool" "docker_pool" {
  name        = var.work_pool_name
  type        = "docker"
  description = ""

  base_job_template = jsonencode({
    job_configuration = {
      image   = "prefecthq/prefect:3-python3.11-uv"
      # Prefer -lc so PATH and shell expansions are consistent
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
    }
  })
}

resource "prefect_work_pool" "docker_pool" {
  name        = var.work_pool_name
  type        = "docker"
  description = ""

  base_job_template = jsonencode({
    job_configuration = {
      image   = "{{ image }}"
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
    }
    variables = {
      type = "object"
      properties = {
        image = {
          type        = "string"
          default     = "prefecthq/prefect:3-python3.11-uv"
          title       = "Docker Image"
          description = ""
        }
      }
      required = ["image"]
    }
  })
}

uv sync

command = "sh -lc 'cd subdir && uv sync --system-site-packages && prefect flow-run execute'"

uv sync

terraform {
  required_providers {
    prefect = {
      source  = "PrefectHQ/prefect"
      version = "~> 1.0"
    }
  }
}

provider "prefect" {
  # Self-hosted Server
  host   = var.prefect_api_url   # e.g., <http://localhost:4200/api> (dev) or your ingress URL
  api_key = var.prefect_api_key  # create a service account; for server, leave unset if auth disabled
}

resource "prefect_work_pool" "docker_pool" {
  name = var.work_pool_name
  type = "docker"

  base_job_template = jsonencode({
    job_configuration = {
      image   = "{{ image }}"
      # Prefer sh -lc so login shells and PATH behave as expected
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
      env = {
        ENVIRONMENT = var.environment
      }
      # Optional: map volumes or networks if your flows need them
      # volumes = ["/host/path:/container/path"]
      # network_mode = "bridge"
      # mem_limit = "1g"
    }
    variables = {
      type = "object"
      properties = {
        image = {
          type        = "string"
          default     = "prefecthq/prefect:3-python3.11-uv"
          title       = "Docker Image"
        }
        env = {
          type  = "object"
          title = "Environment Variables"
          additionalProperties = { type = ["string", "null"] }
          default = {}
        }
      }
      required = ["image"]
    }
  })

  tags = ["environment:${var.environment}", "runtime:docker", "code-source:git"]
}

prefect block create

resource "prefect_block" "github_credentials" {
  name      = "github-creds"
  type_slug = "github-credentials"
  data = jsonencode({
    token = var.github_token  # WARNING: ends up in TF state; prefer CI-time creation
  })
}

.deploy()

prefect deploy

resource "prefect_global_concurrency_limit" "io_bound" {
  name      = "io-bound"
  limit     = 20
  active    = true
  slot_decay_per_second = 0
}

resource "prefect_automation" "notify_failures" {
  name = "notify-failures-${var.environment}"

  trigger = {
    type  = "flow-run-state-change"
    match = {
      any_ = [
        { "flow_run": { "tags": ["environment:${var.environment}"] } }
      ]
    }
    after = "2m"  # debounce
    state = "Failed"
  }

  actions = [
    {
      type = "send-notification"
      block_document_name = "slack-notifier"
      payload = jsonencode({
        message = "Flow run {{ flow_run.name }} failed in ${var.environment}"
      })
    }
  ]
}

flow.from_source(..., source=GitRepository(...))

FROM prefecthq/prefect:3-python3.11-uv
USER root
RUN apt-get update && apt-get install -y --no-install-recommends git && rm -rf /var/lib/apt/lists/*
USER prefect

FROM prefecthq/prefect:3-python3.11-uv
USER root
RUN apk add --no-cache git
USER prefect

resource "prefect_work_pool" "docker_pool" {
  name = var.work_pool_name
  type = "docker"

  base_job_template = jsonencode({
    job_configuration = {
      image   = "your-registry/prefect:3.11-uv-with-git"
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
    }
  })
}

uv sync

from_source

resource "prefect_work_pool" "docker_pool" {
  name = var.work_pool_name
  type = "docker"

  base_job_template = jsonencode({
    job_configuration = {
      image   = "{{ image }}"
      # Run flow directly (no git, no uv). If you do need installs, mount a venv/cache too.
      command = "sh -lc 'prefect flow-run execute'"
      # Mount your host/source code into the container
      volumes = ["{{ code_mount }}"]
      # Optional defaults
      env = "{{ env }}"
      stream_output = true
    }
    variables = {
      type = "object"
      properties = {
        image = {
          type    = "string"
          default = "prefecthq/prefect:3-python3.11-uv"
          title   = "Docker image"
        }
        code_mount = {
          type        = "string"
          title       = "Code volume mount"
          description = "Host:Container mount for your code and entrypoint"
          # Example assumes your code lives at /opt/flows inside container
          default     = "/absolute/host/code:/opt/flows:ro"
        }
        env = {
          type  = "object"
          title = "Environment variables"
          additionalProperties = { type = ["string", "null"] }
          default = {}
        }
      }
      required = ["image", "code_mount"]
    }
  })
}

from prefect import flow

@flow
def my_flow():
    ...

if __name__ == "__main__":
    my_flow.deploy(
        name="mount-code-deployment",
        work_pool_name="YOUR_DOCKER_POOL",
        # No image build here; rely on the pool image and the mounted code
        job_variables={
            "image": "prefecthq/prefect:3-python3.11-uv",
            "code_mount": "/home/you/project:/opt/flows:ro",
            "env": {"ENVIRONMENT": "dev"}
        },
        # Ensure Prefect knows where to find the entrypoint at runtime
        entrypoint_type="absolute",
        # Or set via prefect.yaml and `prefect deploy`
    )

prefect deploy

prefect worker start --pool <your-pool>

docker run --rm -it -v /home/you/project:/opt/flows:ro prefecthq/prefect:3-python3.11-uv \
      sh -lc "ls -la /opt/flows && python -c 'import runpy; runpy.run_path(\"/opt/flows/flows/my_flow.py\")'"

pull:
  - prefect.deployments.steps.git_clone:
      id: clone-step
      repository: <https://github.com/owner/repo.git>
      # credentials: {{ your_github_block }}    # for private repos
      # branch: main
  - prefect.deployments.steps.run_shell_script:
      directory: "{{ clone-step.directory }}"
      script: |
        uv --version
        uv sync --system-site-packages

docker run --rm prefecthq/prefect:3-python3.11-uv sh -lc "git --version || echo 'git not found'"

FROM prefecthq/prefect:3-python3.11-uv
  USER root
  RUN apt-get update \
      && apt-get install -y --no-install-recommends git ca-certificates openssh-client \
      && rm -rf /var/lib/apt/lists/*
  USER prefect

RUN mkdir -p /home/prefect/.ssh \
      && ssh-keyscan -t rsa <http://github.com|github.com> >> /home/prefect/.ssh/known_hosts \
      && chown -R prefect:prefect /home/prefect/.ssh

base_job_template = jsonencode({
  job_configuration = {
    image   = "your-registry/prefect:3.11-uv-with-git"
    command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
  }
  variables = {
    type = "object"
    properties = {
      image = { type = "string", default = "your-registry/prefect:3.11-uv-with-git" }
    }
    required = ["image"]
  }
})

prefect

apt-get

flow.from_source(..., source=GitRepository(...))

# runtime image used by the Docker work pool for flow runs
FROM prefecthq/prefect:3-python3.11-uv
USER root
RUN apt-get update \
 && apt-get install -y --no-install-recommends git ca-certificates openssh-client \
 && rm -rf /var/lib/apt/lists/*
# Optional: add GitHub host key for SSH-based clones
# RUN mkdir -p /home/prefect/.ssh \
#  && ssh-keyscan -t rsa <http://github.com|github.com> >> /home/prefect/.ssh/known_hosts \
#  && chown -R prefect:prefect /home/prefect/.ssh
USER prefect

FROM prefecthq/prefect:3-python3.11-uv
USER root
RUN apk add --no-cache git openssh-client ca-certificates
USER prefect

resource "prefect_work_pool" "docker_pool" {
  name = var.work_pool_name
  type = "docker"

  base_job_template = jsonencode({
    job_configuration = {
      image   = "your-registry/prefect:3.11-uv-with-git"
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
      # add env/volumes/etc as needed
    }
  })
}

uv run --with 'prefect[docker]' prefect worker start --pool <your-docker-pool> --type docker

docker run --rm your-registry/prefect:3.11-uv-with-git sh -lc "git --version && uv --version && prefect --version"

docker run --rm -it <your-image> sh -lc "git --version || echo 'git not found'; uv --version || echo 'uv not found'; prefect --version"

FROM prefecthq/prefect:3-latest
USER root
RUN apt-get update \
 && apt-get install -y --no-install-recommends git ca-certificates openssh-client \
 && rm -rf /var/lib/apt/lists/*
# Optional: if you want uv in the image
RUN curl -LsSf <https://astral.sh/uv/install.sh> | sh -s -- -y \
 && ln -s /root/.local/bin/uv /usr/local/bin/uv
# Optional: add known_hosts for SSH-based clones
# RUN mkdir -p /home/prefect/.ssh \
#  && ssh-keyscan -t rsa <http://github.com|github.com> >> /home/prefect/.ssh/known_hosts \
#  && chown -R prefect:prefect /home/prefect/.ssh
USER prefect

FROM prefecthq/prefect:3-latest
USER root
RUN apk add --no-cache git openssh-client ca-certificates curl
RUN curl -LsSf <https://astral.sh/uv/install.sh> | sh -s -- -y \
 && ln -s /root/.local/bin/uv /usr/local/bin/uv
USER prefect

resource "prefect_work_pool" "docker_pool" {
  name = var.work_pool_name
  type = "docker"

  base_job_template = jsonencode({
    job_configuration = {
      image   = "your-registry/prefect:3-with-uv-git"
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
      env     = {}
    }
  })
}

FROM prefecthq/prefect:3.9.x-python3.11-slim  # pin an exact 3.x version
USER root
RUN apt-get update \
 && apt-get install -y --no-install-recommends git ca-certificates openssh-client build-essential \
 && rm -rf /var/lib/apt/lists/*
# Install uv once (pin if you prefer)
RUN curl -LsSf <https://astral.sh/uv/install.sh> | sh -s -- -y \
 && ln -s /root/.local/bin/uv /usr/local/bin/uv

# Copy dependency manifests first to cache installs
WORKDIR /opt/app
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --system-site-packages

# If your dbt project lives in repo, you may install adapters here instead of pyproject
# RUN uv pip install dbt-core dbt-postgres  # if not in pyproject

# Drop to non-root
USER prefect

prefect flow-run execute

image

env

sh -lc 'uv sync --system-site-packages && prefect flow-run execute'

flow.from_source(source=GitRepository(...), entrypoint=...)

from prefect import flow
from prefect_dbt import DbtCoreOperation

@flow
def run_dbt(models: list[str] = None):
    DbtCoreOperation(
        commands=["dbt deps", "dbt build --select " + " ".join(models or ["state:modified+"])],
        env={"DBT_PROFILES_DIR": "/opt/app/profiles"},  # mount or baked path
    ).run()

prefect deploy

FROM prefecthq/prefect:3-latest
USER root

# Install git + SSH client (for private repos) + certs + curl
RUN apt-get update \
 && apt-get install -y --no-install-recommends git ca-certificates openssh-client curl \
 && rm -rf /var/lib/apt/lists/*

# Install uv
RUN curl -LsSf <https://astral.sh/uv/install.sh> | sh -s -- -y \
 && ln -s /root/.local/bin/uv /usr/local/bin/uv

# Optional: add GitHub known_hosts if you use SSH URLs
# RUN mkdir -p /home/prefect/.ssh \
#  && ssh-keyscan -t rsa <http://github.com|github.com> >> /home/prefect/.ssh/known_hosts \
#  && chown -R prefect:prefect /home/prefect/.ssh

USER prefect

[project]
name = "half-baked-demo"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = []

from prefect import flow, get_run_logger

@flow
def hello(name: str = "world"):
    logger = get_run_logger()
    <http://logger.info|logger.info>("Hello, %s!", name)

if __name__ == "__main__":
    hello()

name: half-baked-demo

deployments:
  - name: hello
    entrypoint: flows/flow.py:hello
    work_pool:
      name: docker-pool
    # Tell the job to use the image you build locally below
    job_variables:
      image: half-baked:latest

    # Pull steps: clone repo then run uv
    pull:
      - prefect.deployments.steps.git_clone:
          id: clone
          repository: <https://github.com/your-org/your-repo.git>
          branch: main
          # For private repos, add a credentials block here; ask me for a snippet.

      - prefect.deployments.steps.run_shell_script:
          directory: "{{ clone.directory }}"
          script: |
            uv --version
            uv sync --system-site-packages

version: "3.9"

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    container_name: prefect-server
    environment:
      PREFECT_SERVER_API_HOST: 0.0.0.0
    command: prefect server start --host 0.0.0.0
    ports:
      - "4200:4200"
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('<http://localhost:4200/api/health>', timeout=1)"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    container_name: prefect-docker-worker
    depends_on:
      prefect-server:
        condition: service_healthy
    environment:
      PREFECT_API_URL: <http://prefect-server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    # Ensure docker integration is available inside worker
    command: >
      uv run --with 'prefect[docker]'
      prefect worker start
      --pool docker-pool
    restart: on-failure

docker build -t half-baked:latest .

docker compose up -d

prefect work-pool create docker-pool --type docker

prefect deploy -n hello

prefect deployment run 'half-baked-demo/hello' --param name=WSL2

prefect deploy

prefect deploy

resource "prefect_work_pool" "docker_pool" {
  name = "docker-dev"
  type = "docker"

  base_job_template = jsonencode({
    job_configuration = {
      image   = "{{ image }}"
      command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
      env     = "{{ env }}"
      # optional: volumes, networks, resources
    }
    variables = {
      type = "object"
      properties = {
        image = { type = "string", default = "your-registry/prefect:3.11-uv-git" }
        env = {
          type  = "object"
          additionalProperties = { type = ["string", "null"] }
          default = {}
        }
      }
      required = ["image"]
    }
  })

  tags = ["environment:dev", "runtime:docker", "code-source:git"]
}

name: my-project

deployments:
  - name: hello
    entrypoint: flows/flow.py:hello
    work_pool:
      name: docker-dev
    job_variables:
      image: your-registry/prefect:3.11-uv-git
      env:
        ENVIRONMENT: dev
    pull:
      - prefect.deployments.steps.git_clone:
          id: clone
          repository: <https://github.com/your-org/your-repo.git>
          branch: main
          # credentials: {{ your_github_block }}   # for private repos
      - prefect.deployments.steps.run_shell_script:
          directory: "{{ clone.directory }}"
          script: |
            uv --version
            uv sync --system-site-packages

prefect deploy -n hello

prefect_deployment

prefect deploy

prefect deploy

base_job_template = jsonencode({
  job_configuration = {
    image   = "your-registry/prefect:3.11-uv-git"
    command = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
    env = {
      PREFECT_API_URL = "<http://host.docker.internal:4200/api>"
    }
  }
})

version: "3.9"

networks:
  prefect:
    name: prefect-network
    driver: bridge

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    command: prefect server start --host 0.0.0.0
    environment:
      PREFECT_SERVER_API_HOST: 0.0.0.0
    ports:
      - "4200:4200"
    networks: ["prefect"]

  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    environment:
      PREFECT_API_URL: <http://prefect-server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: >
      uv run --with 'prefect[docker]'
      prefect worker start
      --pool docker-pool
    networks: ["prefect"]

base_job_template = jsonencode({
  job_configuration = {
    image    = "your-registry/prefect:3.11-uv-git"
    command  = "sh -lc 'uv sync --system-site-packages && prefect flow-run execute'"
    networks = ["prefect-network"]
  }
})

docker ps -a

docker logs <container_id>

env = {
      HTTP_PROXY  = "<http://proxy:port>"
      HTTPS_PROXY = "<http://proxy:port>"
      NO_PROXY    = "localhost,127.0.0.1,.yourdomain"
    }

docker run --rm --network prefect-network your-registry/prefect:3.11-uv-git \
    sh -lc "curl -sSf <http://prefect-server:4200/api/health> && echo OK"

docker run --rm your-registry/prefect:3.11-uv-git \
    sh -lc "curl -sSf <http://host.docker.internal:4200/api/health> && echo OK"

deployments:
  - name: your-deployment
    entrypoint: flows/flow.py:your_flow
    work_pool:
      name: docker-pool
    job_variables:
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>

networks:
  prefect:
    name: prefect-network
    driver: bridge

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    command: prefect server start --host 0.0.0.0
    environment:
      PREFECT_SERVER_API_HOST: 0.0.0.0
    ports:
      - "4200:4200"
    networks: ["prefect"]

  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    environment:
      PREFECT_API_URL: <http://prefect-server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: >
      uv run --with 'prefect[docker]'
      prefect worker start
      --pool docker-pool
    networks: ["prefect"]

deployments:
  - name: your-deployment
    entrypoint: flows/flow.py:your_flow
    work_pool:
      name: docker-pool
    job_variables:
      networks:
        - prefect-network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>

prefect deploy -n your-deployment

HTTP_PROXY, HTTPS_PROXY, NO_PROXY

deployments:
  - name: your-deployment
    entrypoint: flows/flow.py:your_flow
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect:3.11-with-uv-git   # ensure uv + git are in this image
      # Optional: if you’re on WSL2 and using host.docker.internal for API
      # env:
      #   PREFECT_API_URL: <http://host.docker.internal:4200/api>
      command: "sh -lc 'uv --version || python -m pip install -U uv; uv sync --system-site-packages && prefect flow-run execute'"

command: "sh -lc 'cd app && uv sync --system-site-packages && cd - && prefect flow-run execute'"

deployments:
  - name: your-deployment
    entrypoint: flows/flow.py:your_flow
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect:3.11-with-uv-git
    pull:
      - prefect.deployments.steps.git_clone:
          id: clone
          repository: <https://github.com/your-org/your-repo.git>
          branch: main
          # credentials: {{ your_github_block }}   # if private
      - prefect.deployments.steps.run_shell_script:
          directory: "{{ clone.directory }}"
          script: |
            uv --version || python -m pip install -U uv
            uv sync --system-site-packages

docker run --rm -it your-registry/prefect:3.11-with-uv-git \
    sh -lc "git --version; uv --version; python -c 'import sys; print(sys.version)'"

prefect deploy -n your-deployment

FROM prefecthq/prefect:3-latest

# Optional: pin exact Prefect and Python variants for reproducibility
# FROM prefecthq/prefect:3.9.x-python3.11

WORKDIR /opt/prefect

# Install system packages you might need for dbt/adapters (example)
# USER root
# RUN apt-get update && apt-get install -y --no-install-recommends \
#     build-essential ca-certificates git openssh-client \
#   && rm -rf /var/lib/apt/lists/*
# USER prefect

# Copy dependency manifests first for better Docker layer caching
COPY pyproject.toml ./
# If you use a lock file, copy it too (poetry.lock/uv.lock/etc.)
# COPY uv.lock ./

# Install your Python deps (pip reads PEP 621/pyproject)
# If using poetry/uv, I can switch this to `uv sync` for you
RUN python -m pip install --upgrade pip \
 && pip install .

# Now copy your application code
COPY flows ./flows

# Default command: Prefect will load/execute the flow via entrypoint
# (no git or runtime installs needed)

[project]
name = "baked-demo"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = [
  "pandas>=2.2.0",
  # "dbt-core==<pin>", "dbt-<your-adapter>==<pin>"  # if you use dbt
]

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

from prefect import flow, get_run_logger
import pandas as pd  # baked into the image

@flow
def hello(name: str = "world"):
    logger = get_run_logger()
    <http://logger.info|logger.info>("Pandas version: %s", pd.__version__)
    <http://logger.info|logger.info>("Hello, %s!", name)

if __name__ == "__main__":
    hello()

name: baked-demo

deployments:
  - name: hello
    # Use an absolute path inside the container for reliability
    entrypoint: /opt/prefect/flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      image: your-dockerhub-or-registry/baked-demo:latest
      # WSL2 Option A: talk to the host-mapped Prefect API port
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>
      # If you prefer Option B (same Docker network), instead include:
      # networks:
      #   - prefect-network
      # env:
      #   PREFECT_API_URL: <http://prefect-server:4200/api>

docker build -t your-dockerhub-or-registry/baked-demo:latest .

prefect work-pool create docker-pool --type docker

prefect deploy -n hello

prefect deployment run "baked-demo/hello" --param name=WSL2

uv sync

# prefect.yaml
deployments:
  - name: your-deployment
    entrypoint: flows/flow.py:your_flow
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect:with-uv-git
      command: "sh -lc 'uv --version || python -m pip install -U uv; uv sync --system-site-packages && prefect flow-run execute'"

pull:
  - prefect.deployments.steps.git_clone:
      id: clone
      repository: <https://github.com/your/repo.git>
      branch: main
  - prefect.deployments.steps.run_shell_script:
      directory: "{{ clone.directory }}"
      script: |
        uv --version || python -m pip install -U uv
        uv sync --system-site-packages

uv sync --system-site-packages

# Dockerfile
FROM prefecthq/prefect:3-latest
WORKDIR /opt/prefect
# ensure uv is present; skip if your base image already has uv
# RUN curl -LsSf <https://astral.sh/uv/install.sh> | sh -s -- -y && ln -s /root/.local/bin/uv /usr/local/bin/uv

COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --system-site-packages
COPY flows ./flows

sh -lc 'cd app && uv sync --system-site-packages && cd - && prefect flow-run execute'

prefect deploy -n your-deployment

uv sync --system-site-packages

# Dockerfile
FROM prefecthq/prefect:3.6.5-python3.11  # pin to match your lock; or regenerate lock for 3.12 if you prefer
WORKDIR /opt/prefect

# Ensure uv is available
RUN python -m pip install -U pip uv

# Copy manifests first for layer caching
COPY pyproject.toml uv.lock ./
# Install project + deps into system site-packages (uses lock)
RUN uv pip install --system --frozen .

# If you’re doing baked-image (no git pull), copy code:
# COPY flows ./flows

FROM prefecthq/prefect:3.6.5-python3.11
WORKDIR /opt/prefect
RUN python -m pip install -U pip uv
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen  # creates .venv here

deployments:
  - name: your-deployment
    entrypoint: flows/flow.py:your_flow
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect:with-uv
      command: "sh -lc '. .venv/bin/activate && prefect flow-run execute'"

FROM prefecthq/prefect:3.6.5-python3.11
WORKDIR /opt/prefect
COPY pyproject.toml ./
RUN python -m pip install -U pip && pip install .
# COPY flows ./flows   # only for baked-image mode

docker build -t your-registry/prefect:with-deps .

prefect deploy -n <your-deployment>

prefect block ls

prefect block inspect <block-type-slug>/<block-name>

prefect block delete <block-type-slug>/<block-name>

name: my-project

deployments:
  - name: hello
    entrypoint: flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect:with-uv-git
      # For WSL2 to reach local server:
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>
      # Optional: networks: ["prefect-network"] if you use a named network
    pull:
      - prefect.deployments.steps.git_clone:
          id: clone
          repository: <https://github.com/your-org/your-repo.git>
          branch: main
          # credentials: github-credentials/my-creds   # only if private
      - prefect.deployments.steps.run_shell_script:
          directory: "{{ clone.directory }}"
          script: |
            uv --version || python -m pip install -U uv
            uv sync && echo "deps ready"

name: my-project

deployments:
  - name: hello
    entrypoint: /opt/prefect/flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect:baked-with-deps
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>
    # No pull/build steps

name: my-project

deployments:
  - name: hello-git
    entrypoint: flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      # Base image the Docker work pool will use for the job container
      image: prefecthq/prefect:3-latest
      # WSL2 tip: point the job at your local server's API
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>

    # Pull steps: clone the repo then install deps in the cloned directory
    pull:
      - prefect.deployments.steps.git_clone:
          id: clone
          repository: <https://github.com/your-org/your-repo.git>
          branch: main
          # For private repos, add:
          # credentials: github-credentials/your-block-name

      - prefect.deployments.steps.run_shell_script:
          directory: "{{ clone.directory }}"
          script: |
            python -m pip install -U uv
            uv --version
            uv sync  # installs deps from pyproject.toml (and uv.lock if present)

name: my-project

deployments:
  - name: hello-baked
    # Point to your flow inside the image (absolute path is most reliable)
    entrypoint: /opt/prefect/flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      # Your prebuilt image that already has code + deps baked in
      image: your-registry/my-project:latest
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>

    # No pull/build steps needed for baked image

prefect deploy -n hello-git

prefect deploy -n hello-baked

. .venv/bin/activate && ...

&&

&&

name: prefect_demo
prefect-version: 3.6.4

# Optional: keep these if you want a custom base image for the git-pull run
build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# Required for git-pull
pull:
- prefect.deployments.steps.git_clone:
    repository: <https://github.com/pohengchou/prefect_demo.git>
    branch: main
    # For private repos, prefer a block:
    # credentials: github-credentials/github-pat-token

# Deployments
deployments:
- name: my_first_deployment
  version: "1.0"
  tags: [demo, docker]
  description: "我的第一個deployment"
  schedule:
    cron: "*/2 * * * *"
    timezone: "Asia/Taipei"
  flow_name: main
  entrypoint: flows/flow.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      # If you kept build/push, use the built image; otherwise point at any image that has git + uv
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      env:
        # WSL2: point jobs at your local server
        PREFECT_API_URL: <http://host.docker.internal:4200/api>
      # Install deps in the cloned repo, then execute
      command: "sh -lc 'python -m pip install -U uv && uv sync && prefect flow-run execute'"

name: my-project

deployments:
  - name: hello-baked
    entrypoint: /opt/prefect/flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/my-project:1.2.3
      image_pull_policy: "IfNotPresent"   # or "Always"
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>

build:
  - prefect_docker.deployments.steps.build_docker_image:
      id: build_image
      requires: prefect-docker>=0.3.1
      image_name: your-registry/my-project
      tag: 1.2.3
      dockerfile: Dockerfile

push:
  - prefect_docker.deployments.steps.push_docker_image:
      requires: prefect-docker>=0.3.1
      image_name: '{{ build_image.image_name }}'
      tag: '{{ build_image.tag }}'

deployments:
  - name: hello-baked
    entrypoint: /opt/prefect/flows/flow.py:hello
    work_pool:
      name: docker-pool
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: "IfNotPresent"
      env:
        PREFECT_API_URL: <http://host.docker.internal:4200/api>

FROM prefecthq/prefect:3-latest
# For stricter reproducibility, pin an exact tag, e.g.:
# FROM prefecthq/prefect:3.6.4-python3.11

WORKDIR /opt/prefect

# Install project dependencies defined in pyproject.toml into system site-packages
# (pip will read [project.dependencies] from pyproject.toml)
COPY pyproject.toml ./
RUN python -m pip install --upgrade pip && pip install .

# Copy your flow code into the image
# Ensure your flow entrypoint path matches this location
COPY flows ./flows

name: prefect_demo
prefect-version: 3.6.4

# Build and push the image during `prefect deploy` (optional if your CI builds/pushes)
build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: your-dockerhub-user/prefect-demo
    tag: v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# No 'pull' section for baked-image method

deployments:
- name: my_baked_deployment
  entrypoint: /opt/prefect/flows/flow.py:main
  work_pool:
    name: docker-pool
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: IfNotPresent
      env:
        # WSL2: point jobs at your local Prefect Server
        PREFECT_API_URL: <http://host.docker.internal:4200/api>
  parameters: {}
  tags: [baked, docker]
  # Optional schedule
  # schedule:
  #   cron: "*/10 * * * *"
  #   timezone: Asia/Taipei

prefect deploy -n my_baked_deployment

prefect deployment run "prefect_demo/my_baked_deployment"

RUN python -m pip install -U pip uv && uv pip install --system --frozen .

networks:
  prefect:
    name: prefect-network
    driver: bridge

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    command: prefect server start --host 0.0.0.0
    ports: ["4200:4200"]
    networks: ["prefect"]

  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    environment:
      PREFECT_API_URL: <http://prefect-server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: >
      uv run --with 'prefect[docker]' prefect worker start --pool docker-pool
    networks: ["prefect"]

deployments:
  - name: my_baked_deployment
    entrypoint: /opt/prefect/flows/flow.py:main
    work_pool:
      name: docker-pool
    job_variables:
      image: your-registry/prefect-demo:latest
      networks:
        - prefect-network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>

PREFECT_API_URL=<http://172.17.0.1:4200/api>

extra_hosts:
  - "host.docker.internal:host-gateway"

job_variables:
  image: your-registry/prefect-demo:latest
  container_create_kwargs:
    host_config:
      ExtraHosts:
        - "host.docker.internal:host-gateway"
  env:
    PREFECT_API_URL: <http://host.docker.internal:4200/api>

FROM prefecthq/prefect:3.6.4-python3.11  # pin to match your Python/lock; adjust as needed

WORKDIR /opt/prefect

# Copy dependency manifest(s) first for better caching
COPY pyproject.toml uv.lock ./

# Install into system site-packages (no venv needed at runtime)
RUN python -m pip install -U pip uv \
 && uv pip install --system --frozen .

# Copy your flow code into the image
COPY flows ./flows

version: "3.9"

networks:
  prefect:
    name: prefect-network
    driver: bridge

services:
  prefect-server:
    image: prefecthq/prefect:3-latest
    command: prefect server start --host 0.0.0.0
    ports:
      - "4200:4200"
    networks: ["prefect"]

  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    depends_on:
      - prefect-server
    environment:
      PREFECT_API_URL: <http://prefect-server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: >
      uv run --with 'prefect[docker]'
      prefect worker start
      --pool docker-pool
    networks: ["prefect"]

name: my_prefect_demo
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# No pull section for baked-image method

deployments:
- name: my_first_deployment
  schedule:
    cron: "*/2 * * * *"
    timezone: "Asia/Taipei"
  flow_name: main
  # Absolute path inside the image is the most robust
  entrypoint: /opt/prefect/flows/main.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: IfNotPresent
      # Ensure the job container joins the same network as your server
      networks:
        - prefect-network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>

docker run --rm --network prefect-network alpine sh -lc "apk add --no-cache curl >/dev/null && curl -sSf <http://prefect-server:4200/api/health> && echo OK"

prefect deploy

export PREFECT_API_URL=<http://localhost:4200/api>
# or persist it to your Prefect profile:
prefect config set PREFECT_API_URL=<http://localhost:4200/api>

prefect config view | grep PREFECT_API_URL

prefect work-pool create docker-pool --type docker
prefect work-pool ls

prefect deploy -n my_first_deployment

PREFECT_API_URL=<http://prefect-server:4200/api>

prefect worker start --pool docker-pool

prefect worker ls

PREFECT_API_URL

<http://localhost:4200/api>

<http://prefect-server:4200/api>

job_variables.networks: ["prefect-network"]

FROM prefecthq/prefect:3.6.4-python3.11  # pin to a known Python; adjust as needed

WORKDIR /opt/prefect

# Copy manifests first for better caching
COPY pyproject.toml uv.lock ./

# Install deps into system site-packages using uv (honors uv.lock)
RUN python -m pip install -U pip uv \
 && uv pip install --system --frozen .

# Copy your flow code
COPY flows ./flows

name: my_prefect_demo
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

deployments:
- name: my_first_deployment
  schedule:
    cron: "*/2 * * * *"
    timezone: "Asia/Taipei"
  flow_name: main
  entrypoint: /opt/prefect/flows/main.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: IfNotPresent
      # If your server and jobs share a Docker network, include it here; otherwise omit
      # networks:
      #   - prefect-network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>

FROM prefecthq/prefect:3.6.4-python3.11
WORKDIR /opt/prefect
COPY pyproject.toml uv.lock ./
RUN python -m pip install -U pip uv && uv sync --frozen
COPY flows ./flows

deployments:
- name: my_first_deployment
  entrypoint: /opt/prefect/flows/main.py:main
  work_pool:
    name: docker-pool
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      command: "sh -lc '. .venv/bin/activate && prefect flow-run execute'"
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>

from prefect import flow, task
import requests
import pandas as pd
import os
from io import BytesIO
from datetime import datetime

URL = "<https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2025-01.parquet>"

@task(log_prints=True, retries=3, retry_delay_seconds=15)
def check_url_available(url: str) -> None:
    print(f"Checking {url} status code")
    resp = requests.head(url, timeout=15, allow_redirects=True)
    resp.raise_for_status()

@task(log_prints=True)
def read_parquet_from_url(url: str) -> pd.DataFrame:
    print(f"Downloading parquet from {url}")
    resp = requests.get(url, timeout=60)
    resp.raise_for_status()
    buf = BytesIO(resp.content)
    df = pd.read_parquet(buf)  # requires pyarrow (or fastparquet) to be installed in the image
    print(f"Loaded {len(df)} rows")
    return df

@task(log_prints=True)
def write_data(df: pd.DataFrame, filepath: str) -> str:
    os.makedirs(os.path.dirname(filepath), exist_ok=True)
    df.to_csv(filepath, index=False)  # fixed: use df.to_csv
    print(f"Wrote {len(df)} rows to {filepath}")
    return filepath

@flow(log_prints=True, name="main")
def main(
    url: str = URL,
    output_dir: str = "data",
    filename_prefix: str = "yellow_tripdata",
) -> str:
    ts = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    filepath = os.path.join(output_dir, f"{filename_prefix}_{ts}.csv")

    check_url_available(url)
    df = read_parquet_from_url(url)
    return write_data(df, filepath)

if __name__ == "__main__":
    # For baked-image deployments, prefer using `prefect deploy` with prefect.yaml.
    # If you really want to deploy from code, provide pool/image explicitly:
    # main().deploy(
    #     name="main",
    #     work_pool_name="docker-pool",
    #     job_variables={"image": "pohengchou/demo:test-v1"},
    # )
    main()

->

<http://df.to|df.to>_csv

df.to_csv

/opt/prefect/flows/main.py:main

python flows/main.py

python -m flows.main

prefect deploy -n my_first_deployment

FROM prefecthq/prefect:3.6.4-python3.11   # pin to match your deps/lock

WORKDIR /opt/prefect
COPY pyproject.toml uv.lock ./

# Install deps into system site-packages (no venv needed at runtime)
RUN python -m pip install -U pip uv \
 && uv pip install --system --frozen .

# Copy your flows
COPY flows ./flows

name: my_prefect_demo
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

deployments:
- name: my_first_deployment
  entrypoint: /opt/prefect/flows/main.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: Always          # avoids stale image during testing
      networks:
        - prefect-network               # if your server & worker share this network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>
  schedule:
    cron: "*/2 * * * *"
    timezone: "Asia/Taipei"

docker build -t pohengchou/demo:test-v1 .
docker push pohengchou/demo:test-v1
prefect deploy -n my_first_deployment

docker ps -a --filter "label=<http://prefect.io/flow-run-id=019ad7d7-f393-7668-93be-32016d99ca1b|prefect.io/flow-run-id=019ad7d7-f393-7668-93be-32016d99ca1b>" --no-trunc
  docker logs <container_id>

job_variables:
    env:
      PREFECT_API_URL: <http://prefect-server:4200/api>
      PREFECT_LOGGING_LEVEL: DEBUG

docker run --rm --network prefect-network pohengchou/demo:test-v1 \
  sh -lc "python -c 'import pandas, pyarrow; import runpy; runpy.run_path(\"/opt/prefect/flows/main.py\")' && echo OK"

FROM prefecthq/prefect:3.6.4-python3.11

WORKDIR /opt/prefect

# Copy dependency manifests first for better layer caching
COPY pyproject.toml uv.lock ./

# Install deps into system site-packages (no venv needed at runtime)
# Uses the locked deps to ensure reproducible builds
RUN python -m pip install -U pip uv \
 && uv export --locked --no-dev -o requirements.txt \
 && pip install -r requirements.txt \
 && rm -f requirements.txt

# Copy your flow code into the image
COPY flows ./flows

name: my_prefect_demo
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: your-dockerhub-user/prefect-demo
    tag: v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# No pull section for baked-image method

deployments:
- name: my_baked_deployment
  # Use an absolute path that matches where you COPY your code in the Dockerfile
  entrypoint: /opt/prefect/flows/main.py:main
  work_pool:
    name: docker-pool
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: IfNotPresent
      # If your server and jobs share a named Docker network, include it (recommended on Linux)
      # networks:
      #   - prefect-network
      env:
        # If using a named Docker network with your server container, use the service name:
        # PREFECT_API_URL: <http://prefect-server:4200/api>
        # Otherwise, if you expose port 4200 on the host, use the host URL:
        PREFECT_API_URL: <http://localhost:4200/api>

pull:
- prefect.deployments.steps.git_clone:
    id: clone
    repository: <https://gitlab.com/<group>/<repo>.git>
    branch: main
    credentials:
      access_token: "{{ prefect.blocks.secret.gitlab-pat.value }}"

pull:
- prefect.deployments.steps.git_clone:
    id: clone
    repository: <https://gitlab.com/<group>/<repo>.git>
    branch: main
    credentials: "{{ prefect.blocks.gitlab-credentials.my-gitlab-creds }}"
# or
#   credentials:
#     access_token: "{{ prefect.blocks.gitlab-credentials.my-gitlab-creds.token }}"

pull:
- prefect.deployments.steps.git_clone:
    id: clone
    repository: <https://gitlab.com/<group>/<repo>.git>
    branch: main
    access_token: "{{ prefect.blocks.secret.gitlab-pat }}"

pull:
- prefect.deployments.steps.git_clone:
    id: clone
    repository: <https://gitlab.com/<group>/<repo>.git>
    branch: main
    credentials: "{{ prefect.blocks.gitlab-credentials.my-gitlab-creds }}"

name: prefect_demo
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

pull:
- prefect.deployments.steps.git_clone:
    id: clone
    repository: <https://gitlab.sltung.com.tw/t15989/docker_git.git>
    branch: main
    access_token: "{{ prefect.blocks.secret.gitlab-pat.value }}"

# If you need Python deps installed from the repo at runtime, add:
- prefect.deployments.steps.run_shell_script:
    directory: "{{ clone.directory }}"
    script: |
      python -m pip install -U uv
      uv sync

deployments:
- name: my_first_deployment
  description: "我的第一個deployment"
  schedule:
    cron: "*/1 * * * *"
    timezone: "Asia/Taipei"
  flow_name: main
  entrypoint: flows/flow.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      # For Linux with a named network, prefer:
      # networks: ["prefect-network"]
      # env: { PREFECT_API_URL: "<http://prefect-server:4200/api>" }
      env:
        PREFECT_API_URL: "<http://localhost:4200/api>"
      # Remove venv activation unless you actually created one; default command is fine:
      # command: "prefect flow-run execute"

pull:
- prefect.deployments.steps.git_clone:
    id: clone
    repository: <https://gitlab.sltung.com.tw/t15989/docker_git.git>
    branch: main
    credentials: "{{ prefect.blocks.gitlab-credentials.my-gitlab-creds }}"

&&

&&

prefect worker ls

image: '{{ build_image.image }}'

image

image: '{{ build_image.image_name }}:{{ build_image.tag }}'

dockerfile: auto

/opt/prefect/<project-name>

dockerfile: Dockerfile

uv sync

prefect

FROM prefecthq/prefect:3.6.4-python3.11
WORKDIR /opt/prefect

COPY pyproject.toml uv.lock ./
RUN python -m pip install -U pip uv \
 && uv export --locked --no-dev -o requirements.txt \
 && pip install -r requirements.txt \
 && rm requirements.txt

COPY flows ./flows

name: prefect_docker
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo2
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# No pull section for baked images

deployments:
- name: my-deployment
  description: docker baked deployment
  schedule:
    cron: "* * * * *"
    timezone: "Asia/Taipei"
  entrypoint: /opt/prefect/flows/flow.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: Always
      # If your server and jobs share a named network, include it and use the service URL:
      # networks: ["prefect-network"]
      # env: { PREFECT_API_URL: "<http://prefect-server:4200/api>" }
      env:
        PREFECT_API_URL: "<http://localhost:4200/api>"

uv sync

FROM prefecthq/prefect:3.6.4-python3.11
WORKDIR /opt/prefect

COPY pyproject.toml uv.lock ./
RUN python -m pip install -U pip uv && uv sync --frozen

COPY flows ./flows

name: prefect_docker
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo2
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

deployments:
- name: my-deployment
  entrypoint: /opt/prefect/flows/flow.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: Always
      command: "sh -lc '. /opt/prefect/.venv/bin/activate && prefect flow-run execute'"
      env:
        PREFECT_API_URL: "<http://localhost:4200/api>"

dockerfile: auto

/opt/prefect/prefect_docker

dockerfile: Dockerfile

/opt/prefect/flows/flow.py:main

docker build -t pohengchou/demo2:test-v1 .

docker push pohengchou/demo2:test-v1

prefect deploy -n my-deployment

docker logs <id>

PREFECT_LOGGING_LEVEL: DEBUG

FROM prefecthq/prefect:3.6.4-python3.11  # pin to match your code/lock; avoid :latest for reproducibility

WORKDIR /opt/prefect

# Copy dependency manifests first for better layer caching
COPY pyproject.toml uv.lock ./

# Install deps into system site-packages (no venv to activate at runtime)
RUN python -m pip install -U pip uv \
 && uv export --locked --no-dev -o requirements.txt \
 && pip install -r requirements.txt \
 && rm -f requirements.txt

# Copy your flow code into the image
COPY flows ./flows

name: prefect_docker
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo2
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# No pull section for baked-image deployments

deployments:
- name: my-deployment
  description: docker baked deployment
  schedule:
    cron: "* * * * *"
    timezone: "Asia/Taipei"
  # Use an absolute path that matches the Dockerfile COPY location
  entrypoint: /opt/prefect/flows/flow.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      # IMPORTANT: reference name + tag from the build step
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      # During testing, force fresh pulls to avoid stale images
      image_pull_policy: Always
      # If your Prefect Server + worker run on a named Docker network (recommended on Linux),
      # attach jobs to that network and use the service URL:
      # networks:
      #   - prefect-network
      # env:
      #   PREFECT_API_URL: <http://prefect-server:4200/api>

      # If you're exposing 4200 on the host and not using a shared network, use the host URL:
      env:
        PREFECT_API_URL: <http://localhost:4200/api>

image_name:tag

/opt/prefect/flows/flow.py:main

>=

&&

image_pull_policy: Always

prefect config set PREFECT_API_URL=<http://localhost:4200/api>

prefect work-pool create docker-pool --type docker

prefect deploy -n my-deployment

prefect deployment run "prefect_docker/my-deployment"

prefect-network

networks

PREFECT_API_URL

<http://prefect-server:4200/api>

version: "3.9"

networks:
  prefect:
    name: prefect-network
    driver: bridge

services:
  postgres:
    image: postgres:14
    networks: [prefect]
    ...
  redis:
    image: redis:7
    networks: [prefect]
    ...
  prefect-server:
    image: prefecthq/prefect:3-latest
    networks: [prefect]
    environment:
      PREFECT_SERVER_API_HOST: 0.0.0.0
    command: prefect server start --host 0.0.0.0
    ports: ["4200:4200"]
    ...
  prefect-docker-worker:
    image: prefecthq/prefect:3-latest
    networks: [prefect]
    environment:
      PREFECT_API_URL: <http://prefect-server:4200/api>
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: >
      uv run --with 'prefect[docker]'
      prefect worker start --pool docker-pool

deployments:
  - name: my-deployment
    entrypoint: /opt/prefect/flows/flow.py:main
    work_pool:
      name: docker-pool
      job_variables:
        image: your-registry/your-image:tag
        networks:
          - prefect-network
        env:
          PREFECT_API_URL: <http://prefect-server:4200/api>

job_variables:
  networks:
    - <yourproject>_default
  env:
    PREFECT_API_URL: <http://prefect-server:4200/api>

FROM prefecthq/prefect:3.6.4-python3.11

WORKDIR /opt/prefect

# Copy dependency manifests first for caching
COPY pyproject.toml uv.lock ./

# Install deps into system site-packages (no venv needed at runtime)
RUN python -m pip install -U pip uv \
 && uv export --locked --no-dev -o requirements.txt \
 && pip install -r requirements.txt \
 && rm -f requirements.txt

# Copy your flow code into the image
COPY flows ./flows

name: prefect_docker
prefect-version: 3.6.4

build:
- prefect_docker.deployments.steps.build_docker_image:
    id: build_image
    requires: prefect-docker>=0.3.1
    image_name: pohengchou/demo2
    tag: test-v1
    dockerfile: Dockerfile

push:
- prefect_docker.deployments.steps.push_docker_image:
    requires: prefect-docker>=0.3.1
    image_name: '{{ build_image.image_name }}'
    tag: '{{ build_image.tag }}'

# No pull section for baked-image deployments

deployments:
- name: my-deployment
  description: docker baked deployment
  schedule:
    cron: "* * * * *"
    timezone: "Asia/Taipei"
  entrypoint: /opt/prefect/flows/flow.py:main
  work_pool:
    name: docker-pool
    work_queue_name: default
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: Always
      networks:
        - prefect-network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>

main

docker build -t pohengchou/demo2:test-v1 .

docker push pohengchou/demo2:test-v1

prefect config set PREFECT_API_URL=<http://localhost:4200/api>

prefect work-pool create docker-pool --type docker

prefect deploy -n my-deployment

docker run --rm --network prefect-network pohengchou/demo2:test-v1 \
    sh -lc "python -c 'import pandas, pyarrow; import runpy; runpy.run_path(\"/opt/prefect/flows/flow.py\")' && echo OK"

docker pull pohengchou/demo2:test-v1
docker run --rm -it pohengchou/demo2:test-v1 sh -lc "python -V; ls -la /opt/prefect; echo; ls -la /opt/prefect/flows || true"

FROM prefecthq/prefect:3.6.4-python3.11
WORKDIR /opt/prefect

COPY pyproject.toml uv.lock ./
RUN python -m pip install -U pip uv \
 && uv export --locked --no-dev -o requirements.txt \
 && pip install -r requirements.txt \
 && rm -f requirements.txt

COPY flows ./flows

deployments:
  - name: my-deployment
    entrypoint: /opt/prefect/flows/flow.py:main        # or main.py:main if that’s your file
    work_pool:
      name: docker-pool
      job_variables:
        image: '{{ build_image.image_name }}:{{ build_image.tag }}'
        image_pull_policy: Always
        networks: [prefect-network]
        env:
          PREFECT_API_URL: <http://prefect-server:4200/api>

requires: prefect-docker>=0.3.1

requires: prefect-docker>=0.3.1

PREFECT_API_URL: <http://prefect-server:4200/api>

PREFECT_API_URL: <http://prefect-server:4200/api>

docker run

uv sync

deployments:
- name: my-deployment
  entrypoint: /opt/prefect/flows/flow.py:main
  work_pool:
    name: docker-pool
    job_variables:
      image: '{{ build_image.image_name }}:{{ build_image.tag }}'
      image_pull_policy: Always
      networks:
        - prefect-network
      env:
        PREFECT_API_URL: <http://prefect-server:4200/api>
      command: "sh -lc '. /opt/prefect/.venv/bin/activate && prefect flow-run execute'"

FROM prefecthq/prefect:3.6.4-python3.11  # or pin a 3.12 tag and regenerate lock
WORKDIR /opt/prefect
COPY pyproject.toml uv.lock ./
RUN python -m pip install -U pip uv \
 && uv export --locked --no-dev -o requirements.txt \
 && pip install -r requirements.txt \
 && rm -f requirements.txt
COPY flows ./flows

prefect:3.6.4-python3.11

/opt/prefect/flows/flow.py:main

prefect-network

prefect-server

prefect deploy -n my-deployment

docker ps -a --filter "label=<http://prefect.io/flow-run-id=<flow-run-id|prefect.io/flow-run-id=<flow-run-id>>"

docker logs <container_id>