Skip to content

Deploy with Claude Code ​

Plane publishes a Claude Code plugin, Plane Self-Hosting, that lets Claude deploy and manage a self-hosted Plane instance on infrastructure you control. You install the plugin, then ask Claude to deploy Plane. It works out what your infrastructure can run, asks you a few questions, and follows the same supported procedures documented in this section.

The plugin covers both editions and every install method:

EditionMethods
CommunityDocker Compose (setup.sh), Docker Swarm, Kubernetes with the plane-ce chart, Docker AIO for evaluation
Commercialprime-cli, Docker Compose, Kubernetes with the plane-enterprise chart, Podman quadlets, Docker Swarm, Portainer, Coolify, Docker AIO for evaluation, and Airgapped Edition, plus license activation

Install the plugin ​

In a Claude Code session (Claude Code 2.1.275 or later):

text
/plugin install plane-self-hosting --marketplace makeplane/plane-claude-plugin

Or from your shell:

bash
claude plugin marketplace add makeplane/plane-claude-plugin
claude plugin install plane-self-hosting@makeplane

The same marketplace also has the plane plugin, which connects Claude Code to your Plane Cloud workspace through Plane's MCP server.

Deploy ​

Start Claude Code on the machine that will run Plane, or on a machine with kubectl access to your cluster, and ask in your own words:

text
Deploy Plane on this server for plane.example.com

You can also start the skill directly with /plane-self-hosting:deploy-plane.

Claude then works through these steps:

  1. Probes your environment, read-only. It checks the OS and architecture, CPU, RAM and disk, Docker, Compose, Podman and Swarm, your Kubernetes contexts (ingress controller, storage class, cert-manager, OpenShift), any existing Plane install, and whether Plane's endpoints are reachable. It shows you what it found.

  2. Recommends and asks, in two short rounds. It offers only the options your infrastructure can run and recommends one.

    • Round 1: where and what
      • Edition: Community or Commercial. Commercial runs on the Free plan until you activate a license.
      • Platform: Docker on this host, Kubernetes, or another container platform (Podman, Swarm, Portainer, Coolify).
      • Access: your domain, and how to handle TLS (Let's Encrypt, your own certificate, cert-manager, or plain HTTP).
    • Round 2: how
      • Method: for Docker, prime-cli, Docker Compose or Docker AIO (evaluation only). For Kubernetes, the Helm chart.
      • Datastores: bundled, or your own PostgreSQL, Redis, RabbitMQ and S3-compatible storage.
      • Add-ons (Commercial): Plane AI, advanced search, the Plane MCP server (Kubernetes only), integrations such as GitHub, GitLab and Slack, intake email, and sensitive data scanning. Claude offers only the add-ons your method supports.

    Core services such as the web app, Space and real-time collaboration, along with the services behind automations and webhooks, are always installed. On Kubernetes, Claude turns on the ones the Helm chart leaves off by default.

  3. Shows a plan and waits for your approval. The plan lists the files it will create, the secrets it will generate (names only) and the commands it will run.

  4. Installs, generating every secret straight into the env or values file.

  5. Verifies the deployment through the health check endpoints and container or pod status. It then walks you through the God Mode first login that makes you the instance admin and, for Commercial, license activation.

  6. Hands over a runbook. It writes a PLANE_DEPLOYMENT.md next to the install with your upgrade, backup and restore commands, and no secrets. A later Claude session reads it when you ask it to upgrade or troubleshoot the instance.

Upgrade an existing instance ​

Claude can upgrade an instance it did not install. Ask in your own words:

text
Upgrade this Plane instance to the latest version

It reads the PLANE_DEPLOYMENT.md runbook if one is there, works out the current version, edition and install method, and follows Update Plane version. It offers a backup before anything irreversible and verifies through the health check endpoints afterwards.

Upgrading RabbitMQ 3.13 to 4.2.9 ​

RabbitMQ 3.13 is end of life and no patched image is published beyond 3.13.6-management-alpine, so Plane ships rabbitmq:4.2.9-management-alpine as the chart default. This is the one upgrade where the broker and the application have to move together, so Claude treats it as its own flow rather than part of a version bump.

Plane moves first, or not at all

RabbitMQ 4.x rejects any connection that negotiates a frame_max below 8192, and the amqplib client in Plane's Node services defaulted to 4096 until 0.10.6. A Plane release older than v4.1.0 therefore cannot connect to a 4.2 broker at all — and because it is a connection-level rejection, silo, live and flux keep reporting Ready while their consumers drop to zero. Integrations, imports and exports stop, Celery carries on working, and nothing crashes. It reads as a partial outage rather than a version mismatch.

Claude works through it in this order:

  1. Reads the amqplib version out of the running image rather than trusting the image tag. It inspects pnpm's store directly, because require("amqplib/package.json") fails on a healthy image and a broken one alike and so proves nothing.
  2. Upgrades Plane first if the floor is not met. The chart enforces the same floor through rabbitmq.minPlaneVersion, so a Helm upgrade below it fails with an explanation instead of deploying a stack whose consumers cannot connect.
  3. Checks the broker's feature flags. A 3.13 node needs every stable flag enabled before a major upgrade, and a node with the experimental khepri_db flag enabled cannot be upgraded to 4.x at all.
  4. Takes a volume snapshot. An in-place upgrade is one-way: once a 4.2 node has opened a data directory, 3.13 can never reopen it, and a downgrade attempt hangs without ever binding the AMQP port.
  5. Upgrades the broker on the same volume and the same pod name, so the Erlang node name — and with it the queues — survives.
  6. Restarts the Celery workers once, after the topology exists. Celery sets up native delayed delivery at consumer start, so a worker that loses that race runs with no delayed delivery for its whole lifetime; every scheduled task it then picks up occupies a worker slot until its due time.
  7. Verifies by consumer count, not pod status, because both known failure modes leave pods Ready.

Queue type is immutable, so an in-place upgrade keeps your existing queues classic. Moving to quorum queues means declaring them fresh on a new broker and draining the old one, which Claude offers as a separate and considerably longer path.

Built-in guardrails ​

The plugin tells Claude to follow these rules throughout:

  • Never print secrets, license keys, or populated env and values files in the conversation. Values only you have, such as an LLM API key or an OAuth client secret, are typed into the file or UI by you, not pasted into the chat.
  • Stop and ask before touching an existing Plane install, and never delete Docker volumes or Kubernetes PVCs.
  • Require your explicit confirmation for destructive operations, after offering a backup.
  • Download installer scripts to a file and summarize them for you before running anything.
  • Use only environment variables and Helm values that exist in the release you're installing.
  • Treat Docker AIO as evaluation-only, and say so.

Claude Code also asks your permission before running commands, so you stay in control of every step it takes on your infrastructure.

Requirements ​

  • Claude Code, installed and signed in, on the target machine or on a machine with kubectl access to the target cluster.
  • The same minimums as a manual install: 2 vCPU, 4 GB RAM (8 GB recommended) and 20 GB of free disk for a Docker host.

TIP

The plugin automates the supported install methods. It doesn't replace them. Everything Claude does maps to the guides in this section, so you can continue by hand from wherever Claude leaves off.