`
**Worker Helm chart**
If you host your agents in a Kubernetes cluster, you can use the [Prefect worker Helm chart](https://github.com/PrefectHQ/prefect-helm/tree/main/charts/prefect-worker)
to host workers in your cluster.
## Upgrade steps
If you have existing deployments that use infrastructure blocks, you can quickly upgrade them to
be compatible with workers by following these steps:
1. **[Create a work pool](/3.0rc/deploy/work-pools/control-runs/#work-pool-configuration)**
This new work pool replaces your infrastructure block.
You can use the [`.publish_as_work_pool`](https://docs.prefect.io/2.19.2/api-ref/prefect/infrastructure/#prefect.infrastructure.Infrastructure.publish_as_work_pool)
method on any infrastructure block to create a work pool with the same configuration.
For example, if you have a `KubernetesJob` infrastructure block named 'my-k8s-job', you can
create a work pool with the same configuration with this script:
```python fixture:my_k8s_job notest
from prefect_kubernetes import KubernetesJob
KubernetesJob.load("my-k8s-job").publish_as_work_pool()
```
Running this script creates a work pool named 'my-k8s-job' with the same configuration
as your infrastructure block.
**Serving flows**
If you are using a `Process` infrastructure block and a `LocalFilesystem` storage block
(or aren't using an infrastructure and storage block at all), you can use [`flow.serve`](/3.0rc/api-ref/prefect/flows/#prefect.flows.Flow.deploy)
to create a deployment without specifying a work pool name or start a worker.
This is a quick way to create a deployment for a flow and manage your
deployments if you don't need the dynamic infrastructure creation or configuration offered
by workers.
Check out our [Docker guide](/3.0rc/deploy/dynamic-infra/deploy-docker/) for how to build a
served flow into a Docker image and host it in your environment.
2. **[Start a worker](/3.0rc/deploy/work-pools/control-runs/#starting-a-worker)**
This worker replaces your agent and polls your new work pool for flow runs to execute.
```bash
prefect worker start -p
```
3. **Deploy your flows to the new work pool**
To deploy your flows to the new work pool, use `flow.deploy` for a Pythonic deployment
experience or `prefect deploy` for a YAML-based deployment experience.
If you currently use `Deployment.build_from_flow`, we recommend using `flow.deploy`.
If you currently use `prefect deployment build` and `prefect deployment apply`, we recommend
using `prefect deploy`.
### `flow.deploy`
If you have a Python script that uses `Deployment.build_from_flow`, you can replace it with
`flow.deploy`.
You can translate most arguments to `Deployment.build_from_flow` directly to `flow.deploy`,
but here are some possible changes you may need:
* Replace `infrastructure` with `work_pool_name`.
* If you've used the `.publish_as_work_pool` method on your infrastructure block, use the
name of the created work pool.
* Replace `infra_overrides` with `job_variables`.
* Replace `storage` with a call to [`flow.from_source`](/3.0rc/api-ref/prefect/flows/#prefect.flows.Flow.deploy).
* `flow.from_source` loads your flow from a remote storage location and makes it deployable.
You can pass your existing storage block to the `source` argument of `flow.from_source`.
Below are some examples of how to translate `Deployment.build_from_flow` to `flow.deploy`.
#### Deploying without any blocks
If you aren't using any blocks:
```python
from prefect import flow
@flow(log_prints=True)
def my_flow(name: str = "world"):
print(f"Hello {name}! I'm a flow from a Python script!")
if __name__ == "__main__":
Deployment.build_from_flow(
my_flow,
name="my-deployment",
parameters=dict(name="Marvin"),
)
```
You can replace `Deployment.build_from_flow` with `flow.serve` :
```python
from prefect import flow
@flow(log_prints=True)
def my_flow(name: str = "world"):
print(f"Hello {name}! I'm a flow from a Python script!")
if __name__ == "__main__":
my_flow.serve(
name="my-deployment",
parameters=dict(name="Marvin"),
)
```
This starts a process that serves your flow and executes any flow runs that are scheduled
to start.
#### Deploying using a storage block
If you currently use a storage block to load your flow code but no infrastructure block:
```python fixture:demo_repo
from prefect import flow
from prefect_github import GitHubRepository
@flow(log_prints=True)
def my_flow(name: str = "world"):
print(f"Hello {name}! I'm a flow from a GitHub repo!")
if __name__ == "__main__":
Deployment.build_from_flow(
my_flow,
name="my-deployment",
storage=GitHubRepository.load("demo-repo"),
parameters=dict(name="Marvin"),
)
```
You can use `flow.from_source` to load your flow from the same location and `flow.serve` to
create a deployment:
```python fixture:demo_repo
from prefect import flow
from prefect_github import GitHubRepository
if __name__ == "__main__":
flow.from_source(
source=GitHubRepository.load("demo-repo"),
entrypoint="example.py:my_flow"
).serve(
name="my-deployment",
parameters=dict(name="Marvin"),
)
```
This allows you to execute scheduled flow runs without starting a worker. Additionally,
the process serving your flow regularly checks for updates to your flow code, and automatically
updates the flow if it detects any changes to the code.
#### Deploying using an infrastructure and storage block
For the code below, you need to create a work pool from your infrastructure block and pass it to
`flow.deploy` as the `work_pool_name` argument. You also need to pass your storage block to
`flow.from_source` as the `source` argument.
```python fixture:demo_repo fixture:my_k8s_job notest
from prefect import flow
from prefect.deployments import Deployment
from prefect.infrastructure.kubernetes import KubernetesJob
from prefect_github import GitHubRepository
@flow(log_prints=True)
def my_flow(name: str = "world"):
print(f"Hello {name}! I'm a flow from a GitHub repo!")
if __name__ == "__main__":
Deployment.build_from_flow(
my_flow,
name="my-deployment",
storage=GitHubRepository.load("demo-repo"),
entrypoint="example.py:my_flow",
infrastructure=KubernetesJob.load("my-k8s-job"),
infra_overrides=dict(pull_policy="Never"),
parameters=dict(name="Marvin"),
)
```
The equivalent deployment code using `flow.deploy` should look like this:
```python fixture:demo_repo
from prefect import flow
from prefect_github import GitHubRepository
if __name__ == "__main__":
flow.from_source(
source=GitHubRepository.load("demo-repo"),
entrypoint="example.py:my_flow"
).deploy(
name="my-deployment",
work_pool_name="my-k8s-job",
job_variables=dict(pull_policy="Never"),
parameters=dict(name="Marvin"),
)
```
When using `flow.from_source(...).deploy(...)`, the flow you're deploying does not
need to be available locally before running your script.
#### Deploying via a Docker image
If you currently bake your flow code into a Docker image before deploying, you can use the
`image` argument of `flow.deploy` to build a Docker image as part of your deployment process:
```python
from prefect import flow
@flow(log_prints=True)
def my_flow(name: str = "world"):
print(f"Hello {name}! I'm a flow from a Docker image!")
if __name__ == "__main__":
my_flow.deploy(
name="my-deployment",
image="my-repo/my-image:latest",
work_pool_name="my-k8s-job",
job_variables=dict(pull_policy="Never"),
parameters=dict(name="Marvin"),
)
```
You can skip a `flow.from_source` call when building an image with `flow.deploy`. Prefect
keeps track of the flow's source code location in the image and loads it from that location when the
flow is executed.
### Using `prefect deploy`
**Always run `prefect deploy` commands from the `root` level of your repo!**
With agents, you may have multiple `deployment.yaml` files. But under worker deployment
patterns, each repo has a single `prefect.yaml` file located at the **root** of the repo
that contains [deployment configuration](/3.0rc/deploy/serve-flows/#working-with-multiple-deployments)
for all flows in that repo.
To set up a new `prefect.yaml` file for your deployments, run the following command from the root
level of your repo:
```bash
prefect deploy
```
This starts a wizard that guides you through setting up your deployment.
**For step 4, select `y` on the last prompt to save the configuration for the deployment.**
Saving the configuration for your deployment results in a `prefect.yaml` file populated
with your first deployment. You can use this YAML file to edit and [define multiple deployments](/3.0rc/deploy/serve-flows/#working-with-multiple-deployments)
for this repo.
You can add more [deployments](/3.0rc/deploy/serve-flows/#deployment-declaration-reference)
to the `deployments` list in your `prefect.yaml` file and/or by continuing to use the deployment
creation wizard.
For more information on deployments, check out our [in-depth guide for deploying flows to work pools](/3.0rc/deploy/work-pools/prefect-deploy/).