Using Codiac with ArgoCD

Add Codiac's orchestration capabilities to your ArgoCD workflows. Codiac is built for platform teams who want Kubernetes to be repeatable and boring—so they can focus on architecture, security, and scale.

Developers deploy with guided CLI commands or Web UI clicks. No YAML editing. No waiting for sync cycles. Platform teams still have full access to ArgoCD and kubectl when needed—but no longer have to use them for day-to-day operations.

Interactive CLI

The Codiac CLI guides you through each command interactively. You don't need to memorize flags—just run the command and answer the prompts.

Why Add Codiac to Your ArgoCD Setup?

Codiac works alongside ArgoCD to solve common challenges:

Simplified configuration: Codiac's dynamic configuration reduces YAML sprawl while working with your existing GitOps workflows
Cluster lifecycle management: ArgoCD excels at deployments; Codiac adds cluster creation, upgrades, and migrations
System-wide versioning: Codiac captures complete environment states for instant rollbacks across all services
Multi-cluster operations: Deploy to dozens of clusters in seconds, whether using ArgoCD or not
Reduced complexity: Simplify your ArgoCD ApplicationSets and HelmReleases with Codiac's configuration hierarchy

Codiac complements ArgoCD:

✅ Keep your GitOps workflows - Codiac works alongside ArgoCD
✅ Reduce YAML duplication across environments
✅ Add cluster lifecycle management (create, upgrade, migrate)
✅ Get instant system-wide rollbacks
✅ Simplify multi-cluster deployments

Use both together or migrate completely - your choice:

Many teams use Codiac for cluster management and configuration while keeping ArgoCD for Git-based deployments
Some teams migrate entirely to Codiac's imperative workflows
Both approaches are valid and well-supported

Key Differences

Feature	ArgoCD	Codiac
Approach	Declarative GitOps (YAML in Git)	Imperative orchestration (CLI/API)
Configuration	Build-time (separate manifests per env)	Deploy-time (dynamic config)
Deployment trigger	Git commit → ArgoCD syncs	CLI command or API call
Rollbacks	Git revert + wait for sync	One-click instant rollback
YAML	Required (extensive manifests)	Optional (simple commands for most cases)
Cluster management	Deployment only	Full lifecycle (create, upgrade, destroy)
Versioning	Git commit history	Complete system snapshots
Sync speed	Polling-based (3-5 min default)	Immediate (on-demand)
Learning curve	High (Kubernetes + GitOps patterns)	Low (abstracts Kubernetes)

Integration Options

You can add Codiac to your existing ArgoCD setup in several ways. Here's how to get started:

Option 1: Run Both Together (Recommended for Most Teams)

Keep ArgoCD for Git-based deployments, add Codiac for:

Cluster lifecycle management (create, upgrade, migrate)
Dynamic configuration management
System-wide snapshots and rollbacks
Multi-cluster operations

Option 2: Full Migration to Codiac

If you prefer a simpler stack, migrate completely from ArgoCD to Codiac.

Prerequisites (Get These Ready First)

Before you start, make sure you have:

Credential	Why You Need It
Cloud provider admin access	Create clusters, assign IPs, configure networking
Container registry credentials	Pull images (ACR, ECR, Docker Hub, etc.)
Secrets store access	AWS Secrets Manager, Azure Key Vault, or GCP Secret Manager
DNS control	Point subdomain to cluster ingress

With these ready, you eliminate the back-and-forth that typically delays migrations.

Getting Started with Codiac

Step 1: Assessment (1-2 hours)

1. Inventory your ArgoCD applications:

# List all ArgoCD apps
kubectl get applications -n argocd

# Export application configs
argocd app list -o yaml > argocd-apps-inventory.yaml

2. Identify what needs migration:

Application deployments
ConfigMaps and Secrets
Ingress configurations
ApplicationSets (multi-environment patterns)

3. Map ArgoCD concepts to Codiac:

ArgoCD Application → Codiac Asset
ArgoCD Project → Codiac Enterprise
ArgoCD ApplicationSet → Codiac Cabinet (per environment)
Git repo → Container registry + Codiac config

Step 2: Codiac Setup (30 minutes)

1. Install Codiac CLI:

# Requires Node.js v20.13.1+
npm install -g @codiac.io/codiac-cli

# Authenticate to Codiac
codiac login

# Authenticate to your cloud provider
codiac csp login

2. Capture your existing cluster:

codiac cluster capture

The CLI guides you through provider selection, credentials, and cluster identification.

Scripted mode (for automation)

# AWS
codiac cluster capture -n my-cluster -p aws -s 123456789012 -l us-east-1

# Azure
codiac cluster capture -n my-cluster -p azure -s your-subscription-id -l eastus -g your-resource-group

Codiac installs:

Lightweight relay agent for cluster communication
No changes to your existing workloads

Note: ArgoCD can remain running during migration. Remove it after validating Codiac.

Step 3: Migrate First Application (1-2 hours)

Example: Migrating a Node.js API

ArgoCD setup (before):

# argocd-application.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-api
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/mycompany/k8s-manifests
    targetRevision: main
    path: apps/my-api/prod
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Codiac equivalent:

# 1. Create cabinet (namespace equivalent)
codiac cabinet create
# CLI prompts for cabinet name and environment

# 2. Create asset from your container image
codiac asset create
# CLI guides you through registry, image, and asset configuration

# 3. Deploy the asset
codiac asset deploy
# CLI prompts for asset, version, and target cabinet

# 4. Configure environment variables
codiac config set
# CLI prompts for scope, key, and value

# 5. Map your domain
codiac host map
# CLI guides you through domain configuration

What happened:

✅ No YAML files created
✅ CLI guided you through each step
✅ Configuration separated from deployment
✅ Deployment took 2 minutes (not 5+ minutes for ArgoCD sync)

Step 4: Migrate Configuration Management

ArgoCD approach:

k8s-manifests/
├── apps/
│   ├── my-api/
│   │   ├── prod/
│   │   │   ├── deployment.yaml
│   │   │   ├── service.yaml
│   │   │   ├── ingress.yaml
│   │   │   └── configmap.yaml
│   │   ├── staging/
│   │   │   ├── deployment.yaml  (duplicate with minor changes)
│   │   │   ├── service.yaml     (duplicate)
│   │   │   └── ...

Codiac approach (dynamic configuration):

codiac config set
# CLI prompts for:
# - Scope (enterprise, environment, cabinet, or asset level)
# - Configuration key
# - Value

Configuration follows a hierarchy:

Enterprise-level: Applies to all environments
Environment-level: Applies to all cabinets in that environment (e.g., DATABASE_URL differs between prod and staging)
Cabinet-level: Applies to specific cabinet
Asset-level: Applies to specific asset

Result:

One deployment, multiple configurations
Reusable configurations
Clear configuration hierarchy

Step 5: Migrate Secrets

ArgoCD approach (Sealed Secrets or External Secrets Operator):

# sealed-secret.yaml
apiVersion: bitnami.com/v1alpha1
kind: SealedSecret
metadata:
  name: my-api-secrets
spec:
  encryptedData:
    DATABASE_PASSWORD: AgBy3i4OJSWK+PiTySYZZA9rO43cGDEq...

Codiac approach (cloud-native secret stores):

# Capture your secret store (AWS Secrets Manager, Azure Key Vault, etc.)
codiac secretStore capture
# CLI guides you through provider selection and configuration

# Reference secrets in configuration using #REF syntax
codiac config set
# Set value as: #REF{secretStore:secretName}

Benefits:

Secrets stay in cloud provider (never in Git)
Automatic rotation support
IAM-based access control

Step 6: Rollout & Validation

1. Deploy to staging first:

codiac asset deploy
# Select your staging cabinet when prompted

2. Validate functionality:

Test application endpoints
Verify configuration loaded correctly
Check ingress routing

3. Deploy to production:

codiac asset deploy
# Select your production cabinet when prompted

4. Monitor for 24-48 hours:

Compare ArgoCD vs Codiac versions side-by-side
Validate rollback capability via codiac snapshot deploy

5. Remove ArgoCD application:

argocd app delete my-api

Migrating Common ArgoCD Patterns

Pattern 1: Multi-Environment ApplicationSets

ArgoCD ApplicationSet:

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: my-api
spec:
  generators:
  - list:
      elements:
      - env: prod
        namespace: production
      - env: staging
        namespace: staging
  template:
    spec:
      source:
        path: apps/my-api/{{env}}

Codiac equivalent:

# Deploy same asset to multiple cabinets
codiac asset deploy
# Run multiple times, selecting different cabinets when prompted

# Or use snapshots for consistent multi-environment deployments
codiac snapshot deploy

Pattern 2: Helm Charts via ArgoCD

ArgoCD Helm application:

spec:
  source:
    repoURL: https://charts.bitnami.com/bitnami
    chart: postgresql
    targetRevision: 12.1.0
    helm:
      values: |
        auth:
          username: admin
          database: myapp

Codiac equivalent:

Create an asset from a Helm chart:

codiac asset create
# Select "Helm chart" when prompted for asset type
# CLI guides you through chart repository and values

Pattern 3: Sync Waves / Deployment Ordering

ArgoCD sync waves:

metadata:
  annotations:
    argocd.argoproj.io/sync-wave: "1"  # Deploy database first
---
metadata:
  annotations:
    argocd.argoproj.io/sync-wave: "2"  # Then deploy API

Codiac equivalent:

Deploy sequentially via CLI:

# Deploy database first
codiac asset deploy
# Select postgres asset

# Wait for database ready, then deploy API
codiac asset deploy
# Select my-api asset

Real-World Migration Timeline

Most platform migrations take months. Codiac is different. With the right credentials in hand, you can have your ArgoCD applications running on Codiac in hours, not weeks.

Sample Timeline: First Application

Step	Activity	Time
1	Install CLI & capture cluster	30 min
2	Create cabinet	5 min
3	Create asset from container image	5 min
4	Configure environment variables	10-30 min
5	Set up ingress	10 min
6	Deploy & validate	15 min

Total for first application: ~90 minutes

Migration by Team Size

Team Size	Timeline	Notes
< 5 services	1-2 days	Single engineer
10-20 services	1 week	Phased rollout
50+ services	2-4 weeks	Run ArgoCD + Codiac in parallel

Compare this to typical platform migrations that take 3-12 months.

Use Cluster Export

If you're migrating from an existing cluster, codiac cluster export reads your running workloads and generates CLI commands for all your images, ports, and environment variables. What would take hours of manual entry takes 5 minutes.

Common Migration Pitfalls

Pitfall 1: Forgetting to migrate secrets

Problem: ArgoCD pulls secrets from Git (Sealed Secrets). Codiac uses cloud secret stores.

Solution:

# Export secrets from Kubernetes
kubectl get secrets -n production -o yaml > secrets-backup.yaml

# Import to AWS Secrets Manager (or your preferred secret store)
aws secretsmanager create-secret --name prod/db-password --secret-string "..."

# Capture secret store in Codiac
codiac secretStore capture

Pitfall 2: Expecting declarative behavior

Problem: ArgoCD automatically syncs on Git changes. Codiac requires explicit deploy commands.

Solution: Integrate Codiac into CI/CD:

# GitHub Actions
- name: Deploy to Codiac
  run: |
    codiac asset deploy --silent -a my-api -c production

Pitfall 3: Missing health checks

Problem: ArgoCD uses Kubernetes readiness probes. Codiac needs explicit probe configuration.

Solution:

codiac asset probe create
# CLI guides you through probe type, method, path, and port

Comparison: Before & After

Before (ArgoCD)

Developer workflow:
1. Write code
2. Build Docker image
3. Update Kubernetes YAML in Git
4. Commit YAML changes
5. Push to Git
6. Wait 3-5 minutes for ArgoCD sync
7. Debug YAML syntax errors

Configuration:
- Separate YAML files per environment
- ConfigMaps duplicated across envs
- Secrets encrypted in Git (complex tooling)

Rollback:
1. Find previous Git commit
2. Revert YAML changes
3. Push to Git
4. Wait for ArgoCD sync
Total: 5-10 minutes

After (Codiac)

Developer workflow:
1. Write code
2. Build Docker image
3. Deploy: codiac asset deploy (CLI guides you through options)
Total: 30-60 seconds

Configuration:
- Single asset, multiple configs
- Hierarchical inheritance (enterprise → env → cabinet)
- Secrets in cloud provider (secure, no Git)

Rollback:
1. codiac snapshot deploy (select previous version)
Total: 2-3 minutes

Feature Parity Table

ArgoCD Feature	Codiac Equivalent	Notes
Application	Asset	Core deployment unit
Project	Enterprise	Organizational boundary
ApplicationSet	Multiple cabinets	Deploy same asset to many environments
Sync policies	Deployment command	Imperative vs declarative
Automated sync	CI/CD integration	Trigger deploys from pipeline
Sync waves	Sequential deployments	Or use asset dependencies
Health checks	Probes	HTTP, TCP, Exec probes
Resource hooks	Kubernetes jobs	Pre/post deployment jobs
SSO (Dex)	OAuth 2.0 + SAML	Enterprise tier
Multi-cluster	Native	Codiac manages multiple clusters natively

Post-Migration Optimization

1. Simplify CI/CD pipelines:

# Before (with ArgoCD)
- Build image
- Push image
- Update YAML in Git repo
- Commit and push YAML
- Wait for ArgoCD sync

# After (with Codiac)
- Build image
- Push image
- cod asset deploy --cabinet production --asset my-api --update $VERSION

2. Consolidate environments:

Remove duplicate YAML files
Use Codiac's dynamic configuration
Reduce Git repository size

3. Implement system versioning:

# Tag important releases
cod snapshot tags --silent --addTags stable --addTags prod --filterVersions v1.2.3

# Rollback entire system
cod snapshot deploy --version v1.2.2 --cabinet production

Getting Help

Migration assistance:

Contact Support for migration consultation
Visit codiac.io to schedule hands-on migration workshop
Join Discord for community support

Parallel operation: Run ArgoCD and Codiac side-by-side during migration. Use different namespaces to avoid conflicts.

Release Management & Environment Promotion - Why immutable snapshots are more powerful than Git-based state
FAQ: ArgoCD vs Codiac
System Versioning
Dynamic Configuration
CLI Asset Management

Last updated: 2026-01-23

Why Add Codiac to Your ArgoCD Setup?​

Key Differences​

Integration Options​

Option 1: Run Both Together (Recommended for Most Teams)​

Option 2: Full Migration to Codiac​

Prerequisites (Get These Ready First)​

Getting Started with Codiac​

Step 1: Assessment (1-2 hours)​

Step 2: Codiac Setup (30 minutes)​

Step 3: Migrate First Application (1-2 hours)​

Step 4: Migrate Configuration Management​

Step 5: Migrate Secrets​

Step 6: Rollout & Validation​

Migrating Common ArgoCD Patterns​

Pattern 1: Multi-Environment ApplicationSets​

Pattern 2: Helm Charts via ArgoCD​

Pattern 3: Sync Waves / Deployment Ordering​

Real-World Migration Timeline​

Sample Timeline: First Application​

Migration by Team Size​

Common Migration Pitfalls​

Pitfall 1: Forgetting to migrate secrets​

Pitfall 2: Expecting declarative behavior​

Pitfall 3: Missing health checks​

Comparison: Before & After​

Before (ArgoCD)​

After (Codiac)​

Feature Parity Table​

Post-Migration Optimization​

Getting Help​

Related Documentation​

Why Add Codiac to Your ArgoCD Setup?

Key Differences

Integration Options

Option 1: Run Both Together (Recommended for Most Teams)

Option 2: Full Migration to Codiac

Prerequisites (Get These Ready First)

Getting Started with Codiac

Step 1: Assessment (1-2 hours)

Step 2: Codiac Setup (30 minutes)

Step 3: Migrate First Application (1-2 hours)

Step 4: Migrate Configuration Management

Step 5: Migrate Secrets

Step 6: Rollout & Validation

Migrating Common ArgoCD Patterns

Pattern 1: Multi-Environment ApplicationSets

Pattern 2: Helm Charts via ArgoCD

Pattern 3: Sync Waves / Deployment Ordering

Real-World Migration Timeline

Sample Timeline: First Application

Migration by Team Size

Common Migration Pitfalls

Pitfall 1: Forgetting to migrate secrets

Pitfall 2: Expecting declarative behavior

Pitfall 3: Missing health checks

Comparison: Before & After

Before (ArgoCD)

After (Codiac)

Feature Parity Table

Post-Migration Optimization

Getting Help

Related Documentation