Skip to content

Quick Start Guide

Get up and running with RCIIS DevOps in under 30 minutes! This guide assumes you have completed the Prerequisites and Local Development setup.

🚀 5-Minute Quick Deploy

Step 1: Verify Your Environment

# Ensure you're in the project directory
cd rciis-devops

# Verify cluster is running
kubectl cluster-info --context kind-cilium-cluster

# Check ArgoCD is running
kubectl get pods -n argocd

Step 2: Deploy Your First Application

# Deploy the Nucleus application (core RCIIS service)
kubectl apply -f apps/rciis/nucleus/local/

# Watch the deployment
kubectl get applications -n argocd -w

Step 3: Access Your Application

# Port forward to access Nucleus
kubectl port-forward svc/nucleus -n rciis-local 8080:80

# Open in browser: http://localhost:8080

🎉 Congratulations! You now have RCIIS running locally.

📋 Complete Walkthrough

1. Understanding the Project Structure

rciis-devops/
├── apps/
│   ├── infra/          # Infrastructure components
│   └── rciis/          # RCIIS applications
│       ├── nucleus/    # Core application
│       ├── apisix/     # API Gateway
│       ├── kafka-ui/   # Kafka management
│       ├── minio/      # Object storage
│       └── secrets/    # Encrypted secrets
├── charts/
│   └── rciis/          # Custom Helm chart
├── scripts/            # Automation scripts
└── local/              # Local development configs

2. Deploy Infrastructure Components

# Deploy all infrastructure components
kubectl apply -f apps/infra/argocd/local/

# Wait for ArgoCD to be ready
kubectl wait --for=condition=ready pod -l app.kubernetes.io/name=argocd-server -n argocd --timeout=300s
# 1. Deploy ArgoCD
kubectl apply -f apps/infra/argocd/local/

# 2. Deploy cert-manager
kubectl apply -f apps/infra/cert-manager/local/

# 3. Deploy ingress controller
kubectl apply -f apps/infra/ingress-nginx/local/

# 4. Deploy MetalLB (load balancer)
kubectl apply -f apps/infra/metallb/local/

3. Set Up Secret Management

# Create age key for local development
mkdir -p ~/.config/sops/age
age-keygen -o ~/.config/sops/age/keys.txt

# Display public key (save this for team sharing)
echo "Your Age public key:"
age-keygen -y ~/.config/sops/age/keys.txt

# Deploy encrypted secrets
kubectl apply -f apps/rciis/secrets/local/

4. Deploy Core Applications

# Deploy in order (respecting dependencies)

# 1. Deploy MinIO (object storage)
kubectl apply -f apps/rciis/minio/local/

# 2. Deploy Strimzi Kafka
kubectl apply -f apps/rciis/strimzi/local/

# 3. Deploy ApiSIX (API Gateway)
kubectl apply -f apps/rciis/apisix/local/

# 4. Deploy Camel K (integration platform)
kubectl apply -f apps/rciis/camel-k/local/

# 5. Deploy Nucleus (core application)
kubectl apply -f apps/rciis/nucleus/local/

# 6. Deploy Kafka UI (management interface)
kubectl apply -f apps/rciis/kafka-ui/local/

5. Verify Deployments

# Check all applications in ArgoCD
kubectl get applications -n argocd

# Check application health
kubectl get pods --all-namespaces

# Verify services are accessible
kubectl get svc --all-namespaces

Expected output:

NAMESPACE     NAME                 READY   STATUS    RESTARTS   AGE
rciis-local   nucleus-0            1/1     Running   0          5m
rciis-local   minio-7c8f9d5b4-xyz  1/1     Running   0          8m
rciis-local   kafka-0              1/1     Running   0          7m
apisix        apisix-7d4c8b-abc    1/1     Running   0          6m

🔗 Accessing Applications

ArgoCD Dashboard

# Get admin password
kubectl -n argocd get secret argocd-initial-admin-secret \
  -o jsonpath="{.data.password}" | base64 -d && echo

# Port forward
kubectl port-forward svc/argocd-server -n argocd 8080:443

# Access: https://localhost:8080
# Username: admin
# Password: (from above)

Nucleus Application

# Port forward to Nucleus
kubectl port-forward svc/nucleus -n rciis-local 8081:80

# Access: http://localhost:8081

Kafka UI

# Port forward to Kafka UI
kubectl port-forward svc/kafka-ui -n rciis-local 8082:80

# Access: http://localhost:8082

MinIO Console

# Get MinIO credentials
kubectl get secret minio-secret -n rciis-local -o jsonpath="{.data.rootUser}" | base64 -d && echo
kubectl get secret minio-secret -n rciis-local -o jsonpath="{.data.rootPassword}" | base64 -d && echo

# Port forward
kubectl port-forward svc/minio-console -n rciis-local 8083:9001

# Access: http://localhost:8083

🛠️ Development Workflow

1. Make Code Changes

# Edit application configuration
vim apps/rciis/nucleus/local/values.yaml

# Or edit the Helm chart
vim charts/rciis/templates/deployment.yaml

2. Test Changes Locally

# Test Helm chart rendering
helm template nucleus charts/rciis -f apps/rciis/nucleus/local/values.yaml

# Test Kustomize build
kustomize build --enable-alpha-plugins --enable-exec apps/rciis/nucleus/local/

# Validate manifests
kubectl apply --dry-run=client -f generated-manifests.yaml

3. Deploy Changes

# Commit and push changes
git add .
git commit -m "Update nucleus configuration"
git push

# ArgoCD will automatically sync changes
kubectl get applications -n argocd -w
# Apply changes directly
kubectl apply -f apps/rciis/nucleus/local/

# Or use Helm
helm upgrade nucleus charts/rciis -f apps/rciis/nucleus/local/values.yaml

4. Monitor and Debug

# Watch application status
kubectl get pods -n rciis-local -w

# Check application logs
kubectl logs -f deployment/nucleus -n rciis-local

# Debug issues
kubectl describe pod <pod-name> -n rciis-local

🔐 Working with Secrets

Creating New Secrets

# Create a plain secret file
cat > secret.yaml << EOF
apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
stringData:
  username: admin
  password: supersecret
EOF

# Encrypt with SOPS
sops -e --age $(age-keygen -y ~/.config/sops/age/keys.txt) secret.yaml > secret.enc.yaml

# Remove plain file
rm secret.yaml

Using Secrets in Applications

# secret-generator.yaml
apiVersion: viaduct.ai/v1
kind: ksops
metadata:
  name: my-secret-generator
  annotations:
    config.kubernetes.io/function: |
      exec:
        path: ksops
files:
  - secret.enc.yaml

Decrypting Secrets (for debugging)

# Decrypt and view
sops -d secret.enc.yaml

# Edit encrypted file
sops secret.enc.yaml

📊 Monitoring Your Deployment

Resource Usage

# Check resource usage
kubectl top nodes
kubectl top pods --all-namespaces

# Monitor specific application
watch kubectl get pods -n rciis-local

Application Health

# Check application status in ArgoCD
kubectl get applications -n argocd

# Detailed application info
kubectl describe application nucleus -n argocd

# Check sync status
kubectl get application nucleus -n argocd -o jsonpath='{.status.sync.status}'

Logs and Events

# Application logs
kubectl logs -f deployment/nucleus -n rciis-local

# System events
kubectl get events --all-namespaces --sort-by='.lastTimestamp'

# ArgoCD events
kubectl get events -n argocd

🚨 Troubleshooting Quick Fixes

Application Won't Start

# Check pod status
kubectl describe pod <pod-name> -n rciis-local

# Check resource constraints
kubectl top pods -n rciis-local

# Restart deployment
kubectl rollout restart deployment/nucleus -n rciis-local

ArgoCD Sync Issues

# Force sync
kubectl patch application nucleus -n argocd --type='merge' -p='{"spec":{"syncPolicy":{"automated":null}}}'

# Manual sync
kubectl apply -f apps/rciis/nucleus/local/

# Check ArgoCD logs
kubectl logs -f deployment/argocd-application-controller -n argocd

Secret Decryption Issues

# Verify age key
ls -la ~/.config/sops/age/keys.txt

# Test SOPS
echo "test" | sops -e --age $(age-keygen -y ~/.config/sops/age/keys.txt) /dev/stdin

# Check KSOPS
ksops --help

Network Issues

# Test pod connectivity
kubectl exec -it deployment/nucleus -n rciis-local -- wget -qO- http://minio:9000/minio/health/live

# Check DNS
kubectl exec -it deployment/nucleus -n rciis-local -- nslookup kubernetes.default

# Test ingress
curl -H "Host: nucleus.local" http://localhost/

🎯 Next Steps

Now that you have RCIIS running locally, explore these advanced topics:

  1. Architecture Deep Dive - Understand the system design
  2. Security Configuration - Secure your deployment
  3. Operations Guide - Production deployment strategies
  4. Development Guide - Advanced development workflows

Common Next Tasks

  • Add a new service: Copy an existing app structure and modify
  • Update configurations: Edit values.yaml files and let ArgoCD sync
  • Monitor applications: Set up Prometheus and Grafana
  • Scale applications: Modify replica counts in Helm values
  • Add integrations: Use Camel K to create new integration routes

Pro Tip

Use ArgoCD's web UI to visualize your applications and their relationships. It's an excellent way to understand the system architecture!