Destroy a Deployment

Safely destroy deployments and clean up resources using bricks uninstall.

Prerequisites

• Bluebricks CLI installed

• Authenticated with Bluebricks (bricks login)

• Existing deployment to destroy

Quick Start

1. Uninstall by deployment slug:

   bricks uninstall --deployment my-postgres-db --collection production

2. Uninstall by package name:

   bricks uninstall @myorg/postgres --collection production

3. Plan destruction first (recommended):

   bricks uninstall --deployment my-postgres-db --collection production --plan-only

4. Verify destruction:

   bricks deploy list

What Is Uninstalling?

Uninstalling is the process of:

• Creating a destroy plan to review resource deletion

• Removing resources created by the deployment

• Cleaning up dependencies in reverse order

• Handling destruction errors safely

• Verifying cleanup completion

Uninstall Methods

Method 1: Uninstall by Deployment Slug

# Uninstall specific deployment by slug
bricks uninstall --deployment my-postgres-db --collection production

# Plan destruction first (recommended)
bricks uninstall --deployment my-postgres-db --collection production --plan-only

Method 2: Uninstall by Package Name

# Uninstall deployment by package name
bricks uninstall @myorg/postgres --collection production

# If multiple deployments exist, you'll be prompted to select one
bricks uninstall @myorg/postgres --collection production

Destroy Flow

1. Plan Destruction

Always create a destroy plan first to review what will be deleted:

# Create destroy plan without applying
bricks uninstall --deployment my-postgres-db --collection production --plan-only

Review the destruction plan in the web UI:

• Resources to be destroyed

• Resources to be updated (e.g., security group rules)

• Impact on dependent resources

• Destruction order

2. Review and Approve

After creating the plan:

Option A: Via Web UI

• Open the plan URL from the CLI output

• Review all resources to be destroyed

• Click "Approve" to proceed with destruction

Option B: Auto-approve (not recommended)

# Skip plan review and destroy immediately (dangerous!)
bricks uninstall --deployment my-postgres-db --collection production
# Then approve when prompted

3. Verify Destruction

After destruction completes:

# Verify deployment is removed
bricks deploy list

# Check cloud console to ensure resources are deleted
# - AWS Console, GCP Console, Azure Portal, etc.

Deployment Manifest for Uninstall

You can also use a deployment manifest with spec.planOnly: true:

apiVersion: bricks/v1
kind: Deployment
metadata:
  name: my-postgres-db
spec:
  blueprint: @myorg/postgres
  version: "1.0.0"
  environment: production
  planOnly: true  # Plan destruction only
  props:
    instance_type: db.t3.medium

Then uninstall by deployment slug:

bricks uninstall --deployment my-postgres-db --collection production --plan-only

Using GitHub Actions

Automate uninstall operations with the official Bricks GitHub Action:

Plan Destruction on PR

name: Plan Infrastructure Destruction

on:
  pull_request:
    branches: [main]
    paths:
      - 'deployments/destroy/**'

jobs:
  plan-destroy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Create destroy plan
        uses: bluebricks-co/bricks-action@v1
        with:
          command: uninstall
          deployment: my-postgres-db
          env: staging
          plan-only: true
          api-key: ${{ secrets.BRICKS_API_KEY }}

Execute Destruction on Approval

name: Destroy Infrastructure

on:
  workflow_dispatch:
    inputs:
      deployment:
        description: 'Deployment slug to destroy'
        required: true
      environment:
        description: 'Environment'
        required: true
        default: 'staging'
      plan_only:
        description: 'Generate plan only'
        type: boolean
        default: true

jobs:
  destroy:
    runs-on: ubuntu-latest
    environment: ${{ inputs.environment }}  # Require approval
    steps:
      - uses: actions/checkout@v4

      - name: Destroy deployment
        uses: bluebricks-co/bricks-action@v1
        with:
          command: uninstall
          deployment: ${{ inputs.deployment }}
          env: ${{ inputs.environment }}
          plan-only: ${{ inputs.plan_only }}
          api-key: ${{ secrets.BRICKS_API_KEY }}

Automated Cleanup (Non-Production)

name: Cleanup Dev Deployments

on:
  schedule:
    - cron: '0 2 * * 0'  # Weekly on Sunday at 2 AM
  workflow_dispatch:

jobs:
  cleanup:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        deployment: [dev-db-1, dev-db-2, dev-db-3]
    steps:
      - uses: actions/checkout@v4

      - name: Destroy development deployment
        uses: bluebricks-co/bricks-action@v1
        with:
          command: uninstall
          deployment: ${{ matrix.deployment }}
          env: development
          api-key: ${{ secrets.BRICKS_API_KEY }}

Important Considerations

Data Protection

Always backup critical data before destruction:

• Export databases

• Download configuration files

• Archive important logs

• Document resource identifiers

# Example: Backup before destroy
aws rds create-db-snapshot --db-instance-identifier my-db --db-snapshot-identifier pre-destroy-backup
bricks uninstall --deployment my-postgres-db --plan-only

Dependency Management

Destroy resources in the correct order:

• Child deployments first (dependencies)

• Parent deployments last (dependents)

• Shared resources last (VPC, networking)

# Destroy in order
bricks uninstall --deployment app-service --collection prod
bricks uninstall --deployment database --collection prod
bricks uninstall --deployment vpc --collection prod

Resource Cleanup

Some resources may not be automatically destroyed:

• Persistent storage (volumes, snapshots)

• External DNS records

• Manual firewall rules

• Externally created resources

Verify cleanup in cloud console after uninstall.

Best Practices

Always Plan Before Destroy

# ALWAYS use plan-only first
bricks uninstall --deployment my-db --collection prod --plan-only

# Review plan in web UI
# Then approve via web UI

Verify Destruction

# Check deployment status
bricks deploy list

# Verify in cloud console
# - AWS: CloudFormation Stacks, EC2 Resources
# - GCP: Deployment Manager, Compute Resources
# - Azure: Resource Groups, Resources

Collection Safety

Development/Staging collections:

• Can destroy freely

• Test destruction process

• Practice disaster recovery

Production collections:

• Require manual approval

• Create backup first

• Verify destruction plan thoroughly

• Document destruction reason

• Use GitHub environment protection rules

Common Scenarios

Destroy Single Deployment

# Plan destruction
bricks uninstall --deployment my-app --collection production --plan-only

# Review in web UI, then approve via UI

Destroy All Deployments for a Package

# List deployments
bricks deploy list

# Destroy each deployment
bricks uninstall --deployment app-v1 --plan-only
bricks uninstall --deployment app-v2 --plan-only

Destroy with Specific Environment

# Destroy from staging only
bricks uninstall @myorg/app --collection staging --plan-only

# Not production (requires explicit --collection production)

Failed Destruction Recovery

If destruction fails:

# Check deployment status
bricks deploy list

# Review logs in web UI
# Fix any resource locks or dependencies

# Retry destruction
bricks uninstall --deployment my-app --collection production

See also

• Creating Environments -- environment lifecycle and run concepts

• How to Plan Deployments -- preview changes before applying

• Deployment Status Monitoring -- verify destruction completed