| name | anti-legacy:deploy |
| description | Package and deploy the modernized application to the configured deployment target. Supports GCP Cloud Run, AWS ECS/Fargate, Azure AKS, and generic Kubernetes. Generates Dockerfile, CI/CD pipeline config, and deployment manifests. Requires GATE_4_UAT to be cleared. Use when: "deploy the app", "generate the Dockerfile", "create CI/CD config", "package for Cloud Run", "generate Kubernetes manifests", "deployment".
|
anti-legacy:deploy
The final pipeline phase. Takes the verified target codebase and produces
deployment-ready artifacts: Dockerfile, CI/CD pipeline config, and target
platform manifests. Designed to be committed alongside the code so the team's
git repo is the complete, reproducible delivery artifact.
Cross-Platform Notes
Generates text-based deployment configs — no platform CLI required for
artifact generation. Platform CLI commands (gcloud, aws, kubectl) are
provided as reference commands for the team to run.
Config
python3 -c "import json; c=json.load(open('.anti-legacy/config.json')); print(c['target_stack'], c['deployment_target'], c['target_path'])"
Parameters
- deployment_target (optional): override from config. One of:
gcp-cloud-run, aws-ecs, azure-aks, kubernetes, docker-compose
- registry (optional): container registry URL (e.g.
gcr.io/my-project, 123456789.dkr.ecr.us-east-1.amazonaws.com)
- image_name (optional): container image name. Defaults to
{project_name}.
Step 1: Verify GATE_4_UAT is cleared
python3 -c "
import json, sys
m = json.load(open('.anti-legacy/manifest.json'))
g = m['gates']['GATE_4_UAT']
if g['status'] != 'passed':
print(f'BLOCKED: GATE_4_UAT is {g[\"status\"]}. Complete UAT and gate sign-off first.')
sys.exit(1)
print('GATE_4_UAT: cleared ✓')
"
Step 2: Generate Dockerfile
Write {target_path}/Dockerfile appropriate for the target stack:
Java (Maven):
FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=build /app/target/{project_name}-*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
Go:
FROM golang:1.22-alpine AS build
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o {project_name} .
FROM alpine:3.19
WORKDIR /app
COPY --from=build /app/{project_name} .
EXPOSE 8080
ENTRYPOINT ["./{project_name}"]
C# (.NET):
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app
COPY *.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o out
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app/out .
EXPOSE 8080
ENTRYPOINT ["dotnet", "{ProjectName}.dll"]
Python:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]
Step 4: Generate deployment manifests
GCP Cloud Run
Write {target_path}/deploy/cloudrun.yaml:
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
name: {project_name}
annotations:
run.googleapis.com/ingress: all
spec:
template:
metadata:
annotations:
autoscaling.knative.dev/maxScale: "10"
run.googleapis.com/cpu-throttling: "false"
spec:
containerConcurrency: 80
timeoutSeconds: 300
containers:
- image: {registry}/{image_name}:latest
ports:
- containerPort: 8080
resources:
limits:
memory: 512Mi
cpu: "1"
env:
- name: PROJECT_NAME
value: "{project_name}"
AWS ECS (Fargate)
Write {target_path}/deploy/task-definition.json with Fargate task definition.
Write {target_path}/deploy/service.json with ECS service definition.
Kubernetes / Azure AKS
Write {target_path}/deploy/k8s/deployment.yaml, service.yaml, and optionally
ingress.yaml with appropriate selectors and resource limits.
Docker Compose (local / fileshare teams)
Write {target_path}/docker-compose.yml for local development and testing.
Step 5: Generate CI/CD pipeline config
Write a pipeline config appropriate for the team's setup.
GitHub Actions — write {target_path}/.github/workflows/ci.yml:
name: CI/CD
on:
push:
branches: [main]
pull_request:
branches: [main]
jobs:
build-and-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build
run: {stack_build_command}
- name: Test
run: {stack_test_command}
deploy:
needs: build-and-test
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Build image
run: docker build -t {registry}/{image_name}:${{ github.sha }} .
- name: Push image
run: docker push {registry}/{image_name}:${{ github.sha }}
- name: Deploy to {deployment_target}
run: {platform_deploy_command}
GitLab CI — write {target_path}/.gitlab-ci.yml with equivalent stages.
Step 6: Write deployment runbook
Write {target_path}/DEPLOY.md:
- Prerequisites (toolchain, credentials required)
- How to build the image locally
- How to run locally with docker-compose
- How to deploy to {deployment_target}
- How to roll back (previous image tag)
- Health check endpoint
- Environment variables required
Step 7: Done-gate, then register + advance phase to complete
Done-gate (BLOCKING). Before registering the deploy artifact or advancing the
phase, assert that the chosen deploy artifact is a real FILE that deploy actually
wrote. Pick {deploy_artifact} = the manifest file produced for
{deployment_target} — for example Dockerfile (always written by Step 2), or
the platform manifest written in Step 3 (deploy/cloudrun.yaml,
deploy/task-definition.json, deploy/k8s/deployment.yaml, or
docker-compose.yml). It MUST be an existing file, never a directory.
python3 -c "
import os, sys
target_path = '{target_path}'
deploy_artifact = '{deploy_artifact}' # e.g. Dockerfile or deploy/cloudrun.yaml
p = os.path.join(target_path, deploy_artifact)
if not os.path.isfile(p):
print(f'BLOCKED: deploy artifact {p} is missing or not a file. Generate it before completing.')
sys.exit(1)
print(f'Deploy artifact present: {p} ✓')
"
If this assertion FAILS, do NOT run register --status final and do NOT run
advance; surface the missing artifact to the user and stop (the user may fix and
retry). The register --status final and advance complete below are CONDITIONAL
on the assertion passing.
Only on success, register the deploy artifact (a FILE, not a directory) and advance
the phase to complete:
python3 .anti-legacy/run.py manifest register deployment-artifacts \
--path {deploy_artifact} \
--format text \
--produced-by anti-legacy:deploy \
--status final \
--depends-on build-integrity
python3 .anti-legacy/run.py manifest advance complete
Step 8: Final pipeline summary
Print the complete pipeline summary:
Pipeline Complete — {project_name}
===================================
Source: {source_apps_summary}
Target: {target_stack} → {deployment_target}
Phases completed:
✓ Survey → graphs/<app>.db + legacy-graph.digest.txt
✓ Analyze → analysis-report.md
✓ Extraction → coverage-report.json + annotations.jsonl + requirements_graph.json
✓ Blueprint → blueprint.json / blueprint.md
✓ Test → {contract_count} test contracts
✓ Review → review_packet.md (GATE_1 cleared)
✓ Plan → task.md (GATE_2 cleared)
✓ Build → {task_count} tasks (GATE_3 auto-cleared)
✓ UAT → {req_count} requirements reviewed (GATE_4 cleared)
✓ Deploy → Dockerfile + {deployment_target} manifests
Artifacts: .anti-legacy/manifest.json
To deploy:
cd {target_path}
docker build -t {image_name} .
{platform_deploy_command}
Output
{target_path}/Dockerfile — container image definition{target_path}/deploy/ — platform manifests{target_path}/{ci_config} — CI/CD pipeline{target_path}/DEPLOY.md — deployment runbook- Manifest: phase =
complete, pipeline = complete
