> For the complete documentation index, see [llms.txt](https://v2.dataos.info/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://v2.dataos.info/build/july2026/productize/monitor-and-delete.md).

# Monitor & delete

Monitor a deployed Data Product with the DataOS CLI, read its runtime container groups, and delete the deployed resource when it's no longer needed.

A deployed Data Product is represented as a single `vulcan` Resource in DataOS. There's no separate `data-product` resource type to monitor or delete: the same Resource you deployed in [Git & deploy](https://v2.dataos.info/build/july2026/productize/git-and-deploy.md) is the one you inspect at runtime, and the one you delete when the Data Product is no longer needed.

Use runtime monitoring to check whether the Data Product is running, which container groups were created for it, and whether scheduled runs completed successfully.

## Check the runtime

```bash
dataos-ctl resource get runtime -t vulcan -n <name> -r
```

For example:

```bash
dataos-ctl resource get runtime -t vulcan -n orders-analytics -r
```

The output shows the deployed `vulcan` Resource and the container groups created for it.

## Runtime components

A Data Product isn't a single container. It's deployed as a set of runtime components:

* `vulcan-api`: serves the Data Product API and query endpoints.
* `vulcan-plan`: runs the planning step, including `vulcan plan --auto-apply`.
* `vulcan-run`: runs the scheduled Data Product execution.

In the runtime output for `orders-analytics`, these components appear as different container groups:

| Component                  | Aggregate ID                        | Container group type | Example container groups                                              | Expected phase |
| -------------------------- | ----------------------------------- | -------------------- | --------------------------------------------------------------------- | -------------- |
| API stateful pods          | `vulcan-api`                        | `cgroup-stateful`    | `orders-analytics-api-0`, `orders-analytics-api-1`                    | `running`      |
| API stateless service pods | `vulcan-api`                        | `cgroup-stateless`   | `servicev2alphaordersanalyticsapi-6rc9-...`                           | `running`      |
| Plan execution             | `vulcan-plan`                       | `cgroup-workflow`    | `orders-analytics-plan-execute`                                       | `completed`    |
| Scheduled run execution    | `vulcan-run` / `orders-analytics-r` | `cgroup-workflow`    | `orders-analytics-r-execute`, `workflowv2alphaordersanalyticsrun-...` | `completed`    |

## Containers in the runtime

Each container group can include multiple containers. The runtime output identifies the role of each one:

* `primary`: the main workload container. For example, `orders-analytics-api`, `main`, or `ordersanalytics-6rc9-main`.
* `initSideCar`: initialization container that prepares the workload. For example, `orders-analytics-plan-6rc9-ic` or `orders-analytics-r-6rc9-ic`.
* `sideCar`: helper container that supports the workflow. For example, `wait`.

For `orders-analytics`, the runtime contains:

* API containers: `orders-analytics-api`, `ordersanalytics-6rc9-main`, and `ordersanalytics-sc-2`.
* Init sidecars: `orders-analytics-plan-6rc9-ic`, `orders-analytics-r-6rc9-ic`, and `ordersanalytics-6rc9-ic`.
* Workflow helper sidecars: `wait`.

## Check logs for a container group

Use the `CONTAINER GROUP NAME` from the runtime output to inspect logs for a specific API pod, sidecar, plan execution, or run execution.

```bash
dataos-ctl resource log -t vulcan -n <name> --container-group <container-group-name>
```

For example, to check the plan execution logs for `orders-analytics`:

```bash
dataos-ctl resource log -t vulcan -n orders-analytics --container-group orders-analytics-plan-execute
```

To check logs for the API service container group, use one of the `servicev2...` container group names from the runtime output:

```bash
dataos-ctl resource log -t vulcan -n orders-analytics --container-group servicev2alphaordersanalyticsapi-6rc9-748dc448d8-gnhlk
```

If the container group has multiple containers, add `-c` to target one of them. For example, to inspect the sidecar container `ordersanalytics-sc-2`:

```bash
dataos-ctl resource log -t vulcan -n orders-analytics --container-group servicev2alphaordersanalyticsapi-6rc9-748dc448d8-gnhlk -c ordersanalytics-sc-2
```

The same pattern applies to any other sidecar: copy the API `CONTAINER GROUP NAME` from the runtime output, then pass the sidecar's container name with `-c`.

## Read the phase

Use the `PHASE` column to understand the Data Product's state:

* `running` means the API component is live and serving the Data Product.
* `completed` means a workflow component, such as plan or run, finished successfully.
* A failed, pending, or stuck phase means the corresponding component needs investigation.

For a healthy deployed Data Product, API container groups are usually `running`, while plan and run workflow container groups are usually `completed` once they finish.

## Delete the Data Product

Deleting a Data Product means deleting its deployed `vulcan` Resource. This removes every runtime resource created for it, including the API, plan, and run container groups. There's no delete action in the Data Product Hub; deletion only happens through the DataOS CLI.

{% hint style="danger" %}
Deletion is irreversible. If other Resources depend on this Data Product, check dependencies before deleting it.
{% endhint %}

Check dependencies first:

```bash
dataos-ctl resource deps -t vulcan -n <name>
```

Then delete the Resource:

{% tabs %}
{% tab title="Command 1" %}

```bash
dataos-ctl resource delete -t vulcan -n ${{name}}
```

{% endtab %}

{% tab title="Command 2" %}

```bash
dataos-ctl resource delete -i "${{name}}|v1alpha|vulcan"
```

{% endtab %}

{% tab title="Command 3" %}

```bash
dataos-ctl resource delete -f ${{manifest-file-path}}
```

{% endtab %}
{% endtabs %}

**Example:**

```bash
dataos-ctl resource delete -t vulcan -n orders-analytics
```

Add `--cascade` to also delete every Resource that depends on this product, or `--force` to delete past a dependency check that would otherwise block it.

## What gets removed

When the `vulcan` Resource is deleted, DataOS tears down the runtime components it created:

* `vulcan-api` container groups stop serving the Data Product API.
* `vulcan-plan` workflow resources are removed.
* `vulcan-run` workflow resources are removed.
* Completed historical workflow container groups are cleaned up as part of the same teardown.

These are stopped and removed one after another rather than all at once, so deletion takes a few minutes instead of finishing instantly. The Data Product Hub updates automatically once the Resource is gone; there's no separate manual step to remove it from the Hub.

## Verify deletion

```bash
dataos-ctl resource get -t vulcan -n <name>
```

You can also check the runtime again:

```bash
dataos-ctl resource get runtime -t vulcan -n <name> -r
```

If the Resource is still returned, deletion is still in progress. Wait a few minutes and check again.

## Related pages

* [Git & deploy](https://v2.dataos.info/build/july2026/productize/git-and-deploy.md): how the `plan`, `run`, and `api` components get created in the first place.
* [Vulcan → Monitor & delete](https://v2.dataos.info/references/resources/vulcan/monitor-and-delete): the same page, filed under the Vulcan stack reference.
* [Resource commands](https://v2.dataos.info/references/interfaces/command-line-interface/resource): full flag reference for `get runtime`, `log`, `deps`, and `delete`.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://v2.dataos.info/build/july2026/productize/monitor-and-delete.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
