graph TB
 A[Developer Commit] --> B[GitHub Actions]
 B --> C[Automated Testing]
 C --> D[Container Build]
 D --> E[Security Scanning]
 E --> F[Artifact Registry]
 F --> G[ArgoCD Sync]
 G --> H[Kubernetes Deployment]
 H --> I[Health Validation]
 I --> J[Monitoring Integration]
 J --> K[Automated Scaling]
 K --> L[Self-Healing Actions]

# .github/workflows/deploy-wireless-services.yml
name: Deploy Wireless Services on:
 push:
 branches: [main]
 paths: 
 - 'wireless-*/**'
 pull_request:
 branches: [main] env:
 REGISTRY: ghcr.io
 VAULT_ADDR: ${{ secrets.VAULT_ADDR }}
 KUBECONFIG_DATA: ${{ secrets.KUBECONFIG_DATA }} jobs:
 detect-changes:
 runs-on: ubuntu-latest
 outputs:
 services: ${{ steps.changes.outputs.services }}
 steps:
 - name: Checkout repository
 uses: actions/checkout@v4
 with:
 fetch-depth: 0  - name: Detect changed services
 id: changes
 run: |
 CHANGED_SERVICES=$(git diff --name-only HEAD~1 HEAD | grep '^wireless-' | cut -d'/' -f1 | sort -u | jq -R -s -c 'split("\n")[:-1]')
 echo "services=$CHANGED_SERVICES" >> $GITHUB_OUTPUT
 echo "Changed services: $CHANGED_SERVICES"  test-and-build:
 needs: detect-changes
 if: needs.detect-changes.outputs.services != '[]'
 runs-on: ubuntu-latest
 strategy:
 matrix:
 service: ${{ fromJson(needs.detect-changes.outputs.services) }}
 steps:
 - name: Checkout repository
 uses: actions/checkout@v4  - name: Set up Docker Buildx
 uses: docker/setup-buildx-action@v3  - name: Login to Container Registry
 uses: docker/login-action@v3
 with:
 registry: ${{ env.REGISTRY }}
 username: ${{ github.actor }}
 password: <REDACTED> secrets.GITHUB_TOKEN }}  - name: Run service tests
 run: |
 cd ${{ matrix.service }}
 if [ -f "Makefile" ]; then
 make test
 else
 echo "No tests found for ${{ matrix.service }}"
 fi  - name: Build and push Docker image
 uses: docker/build-push-action@v5
 with:
 context: ./${{ matrix.service }}
 push: true
 tags: |
 ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.service }}:${{ github.sha }}
 ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.service }}:latest
 cache-from: type=gha
 cache-to: type=gha,mode=max  - name: Security scan
 uses: aquasecurity/trivy-action@master
 with:
 image-ref: ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.service }}:${{ github.sha }}
 format: 'sarif'
 output: 'trivy-results.sarif'  - name: Upload security scan results
 uses: github/codeql-action/upload-sarif@v2
 with:
 sarif_file: 'trivy-results.sarif'  deploy-dev:
 needs: [detect-changes, test-and-build]
 runs-on: ubuntu-latest
 environment: development
 strategy:
 matrix:
 service: ${{ fromJson(needs.detect-changes.outputs.services) }}
 steps:
 - name: Checkout repository
 uses: actions/checkout@v4  - name: Setup kubectl
 uses: azure/setup-kubectl@v3
 with:
 version: 'v1.28.0'  - name: Configure kubeconfig
 run: |
 echo "${{ env.KUBECONFIG_DATA }}" | base64 -d > $HOME/.kube/config
 chmod 600 $HOME/.kube/config  - name: Update deployment metadata
 run: |
 cd ${{ matrix.service }}  # Update image reference in meta-dev.yml
 sed -i "s|image_ref:.*|image_ref: ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.service }}:${{ github.sha }}|" meta-dev.yml  # Update version timestamp
 sed -i "s|version:.*|version: $(date -u +%Y%m%d%H%M%S)|" meta-dev.yml  - name: Deploy to development
 run: |
 cd ${{ matrix.service }}
 kubectl apply -f meta-dev.yml  - name: Wait for deployment rollout
 run: |
 kubectl rollout status deployment/${{ matrix.service }} -n development --timeout=300s  - name: Run smoke tests
 run: |
 cd ${{ matrix.service }}
 if [ -f "smoke-tests.sh" ]; then
 ./smoke-tests.sh development
 fi  create-deployment-pr:
 needs: [detect-changes, deploy-dev]
 runs-on: ubuntu-latest
 if: github.ref == 'refs/heads/main'
 strategy:
 matrix:
 service: ${{ fromJson(needs.detect-changes.outputs.services) }}
 steps:
 - name: Checkout repository
 uses: actions/checkout@v4
 with:
 token: <REDACTED> secrets.AUTOMATION_TOKEN }}  - name: Update production metadata
 run: |
 cd ${{ matrix.service }}  # Update image reference in meta-prod.yml
 sed -i "s|image_ref:.*|image_ref: ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.service }}:${{ github.sha }}|" meta-prod.yml  # Update version
 sed -i "s|version:.*|version: $(date -u +%Y%m%d%H%M%S)|" meta-prod.yml  - name: Create Pull Request
 uses: peter-evans/create-pull-request@v5
 with:
 token: <REDACTED> secrets.AUTOMATION_TOKEN }}
 commit-message: "Automatic PR: Development changes detected in ${{ matrix.service }}"
 title: "Deploy ${{ matrix.service }} to Production"
 body: |
 ## Automated Production Deployment Request  **Service:** ${{ matrix.service }}
 **Image:** ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.service }}:${{ github.sha }}
 **Triggered by:** ${{ github.actor }}
 **Commit:** ${{ github.sha }}  ### Changes Included
 ${{ github.event.head_commit.message }}  ### Validation Completed
 - ✅ Automated tests passed
 - ✅ Security scanning completed
 - ✅ Development deployment successful
 - ✅ Smoke tests passed  ### Deployment Checklist
 - [ ] Review changes and approve
 - [ ] Verify production readiness
 - [ ] Merge to trigger production deployment  ---
 🤖 This PR was automatically created by the deployment pipeline.
 branch: deployments/${{ matrix.service }}-prod-patch
 delete-branch: true

# project/inventories/dynamic/aws_ec2.yml
plugin: amazon.aws.aws_ec2
regions:
 - us-east-1
 - eu-west-1 
 - ap-southeast-2 filters:
 tag:Environment:
 - development
 - production
 tag:Service:
 - wireless-admin
 - wireless-billing
 - wireless-manager
 - pcap-extractor hostnames:
 - tag:Name
 - dns-name
 - private-ip-address compose:
 project_host: private_ip_address
 service_name: tags.Service | default('unknown')
 environment: tags.Environment | default('unknown')
 region: placement.region groups:
 # Group by service
 wireless_admin: service_name == 'wireless-admin'
 wireless_billing: service_name == 'wireless-billing' 
 wireless_manager: service_name == 'wireless-manager'
 pcap_extractor: service_name == 'pcap-extractor'  # Group by environment
 development: environment == 'development'
 production: environment == 'production'  # Group by region
 us_east_1: region == 'us-east-1'
 eu_west_1: region == 'eu-west-1'
 ap_southeast_2: region == 'ap-southeast-2'

# project/playbooks/deploy-wireless-service.yml
---
- name: Deploy Wireless Service
 hosts: "{{ target_service | default('all') }}"
 become: yes
 serial: "{{ deployment_batch_size | default('30%') }}"
 max_fail_percentage: 5  vars:
 service_config_path: "/opt/wireless/{{ service_name }}"
 backup_retention_days: 30
 health_check_retries: 10
 health_check_delay: 30  pre_tasks:
 - name: Validate deployment parameters
 assert:
 that:
 - service_name is defined
 - service_version is defined
 - environment is defined
 fail_msg: "Required deployment parameters missing"  - name: Create deployment backup
 copy:
 src: "{{ service_config_path }}/current"
 dest: "{{ service_config_path }}/backups/{{ project_date_time.epoch }}"
 remote_src: yes
 ignore_errors: yes  tasks:
 - name: Stop existing service
 systemd:
 name: "{{ service_name }}"
 state: stopped
 register: service_stop
 failed_when: false  - name: Download service artifact
 get_url:
 url: "https://{{ artifact_registry }}/{{ service_name }}/{{ service_version }}/{{ service_name }}.tar.gz"
 dest: "/tmp/{{ service_name }}-{{ service_version }}.tar.gz"
 headers:
 Authorization: "Bearer {{ artifact_token }}"
 validate_certs: yes  - name: Extract service artifact
 unarchive:
 src: "/tmp/{{ service_name }}-{{ service_version }}.tar.gz"
 dest: "{{ service_config_path }}/{{ service_version }}"
 remote_src: yes
 creates: "{{ service_config_path }}/{{ service_version }}/bin/{{ service_name }}"  - name: Update service configuration
 template:
 src: "{{ service_name }}.conf.j2"
 dest: "{{ service_config_path }}/{{ service_version }}/config/{{ service_name }}.conf"
 backup: yes
 notify: restart service  - name: Update service symlink
 file:
 src: "{{ service_config_path }}/{{ service_version }}"
 dest: "{{ service_config_path }}/current"
 state: link
 force: yes
 notify: restart service  - name: Start service
 systemd:
 name: "{{ service_name }}"
 state: started
 enabled: yes
 daemon_reload: yes
 register: service_start  - name: Wait for service health check
 uri:
 url: "http://{{ project_default_ipv4.address }}:{{ service_port | default(8080) }}/health"
 method: GET
 status_code: 200
 register: health_check
 retries: "{{ health_check_retries }}"
 delay: "{{ health_check_delay }}"
 until: health_check.status == 200  - name: Validate service metrics
 uri:
 url: "http://{{ project_default_ipv4.address }}:{{ service_port | default(8080) }}/metrics"
 method: GET
 status_code: 200
 register: metrics_check
 retries: 3
 delay: 10  post_tasks:
 - name: Clean up old artifacts
 file:
 path: "/tmp/{{ service_name }}-{{ service_version }}.tar.gz"
 state: absent  - name: Clean up old backups
 find:
 paths: "{{ service_config_path }}/backups"
 age: "{{ backup_retention_days }}d"
 register: old_backups  - name: Remove old backups
 file:
 path: "{{ item.path }}"
 state: absent
 loop: "{{ old_backups.files }}"  handlers:
 - name: restart service
 systemd:
 name: "{{ service_name }}"
 state: restarted
 daemon_reload: yes
 listen: restart service

# argocd/applications/wireless-services.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
 name: wireless-billing-prod
 namespace: argocd
 finalizers:
 - resources-finalizer.argocd.argoproj.io
spec:
 project: telecommunications
 source:
 repoURL: https://github.com/telecom/deploy-core-wireless
 targetRevision: main
 path: wireless-billing/deployments/k8s/prod/overlays/backend-ch1-prod
 destination:
 server: https://kubernetes.default.svc
 namespace: wireless-billing-prod
 syncPolicy:
 automated:
 prune: true
 selfHeal: true
 allowEmpty: false
 syncOptions:
 - CreateNamespace=true
 - PrunePropagationPolicy=foreground
 - PruneLast=true
 retry:
 limit: 5
 backoff:
 duration: 5s
 factor: 2
 maxDuration: 3m
 revisionHistoryLimit: 10 ---
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
 name: telecommunications
 namespace: argocd
spec:
 description: Telecommunications infrastructure services  sourceRepos:
 - https://github.com/telecom/deploy-core-wireless
 - https://charts.helm.sh/stable  destinations:
 - namespace: '*'
 server: https://kubernetes.default.svc  clusterResourceWhitelist:
 - group: ''
 kind: Namespace
 - group: rbac.authorization.k8s.io
 kind: ClusterRole
 - group: rbac.authorization.k8s.io
 kind: ClusterRoleBinding  namespaceResourceWhitelist:
 - group: ''
 kind: '*'
 - group: apps
 kind: '*'
 - group: networking.k8s.io
 kind: '*'
 - group: monitoring.coreos.com
 kind: '*'  roles:
 - name: developer
 policies:
 - p, proj:telecommunications:developer, applications, get, telecommunications/*, allow
 - p, proj:telecommunications:developer, applications, sync, telecommunications/*, allow
 groups:
 - telecom:developers  - name: operator
 policies:
 - p, proj:telecommunications:operator, applications, *, telecommunications/*, allow
 - p, proj:telecommunications:operator, repositories, *, *, allow
 groups:
 - telecom:operators

# argocd/rollouts/wireless-billing-rollout.yaml
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
 name: wireless-billing
spec:
 replicas: 5
 strategy:
 canary:
 analysis:
 templates:
 - templateName: wireless-billing-success-rate
 startingStep: 2
 args:
 - name: service-name
 value: wireless-billing
 canaryMetadata:
 labels:
 deployment: canary
 steps:
 - setWeight: 20
 - pause:
 duration: 10m
 - setWeight: 40
 - pause:
 duration: 10m
 - analysis:
 templates:
 - templateName: wireless-billing-success-rate
 args:
 - name: service-name
 value: wireless-billing
 - setWeight: 60
 - pause:
 duration: 10m
 - setWeight: 80
 - pause:
 duration: 10m
 - setWeight: 100
 - pause:
 duration: 10m
 abortScaleDownDelaySeconds: 30
 scaleDownDelaySeconds: 30 ---
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
 name: wireless-billing-success-rate
spec:
 args:
 - name: service-name
 metrics:
 - name: success-rate
 successCondition: result[0] >= 0.95
 interval: 5m
 count: 3
 provider:
 prometheus:
 address: http://prometheus.monitoring.svc.cluster.local:9090
 query: |
 sum(rate(http_requests_total{service="{{args.service-name}}",status=~"2.."}[5m])) /
 sum(rate(http_requests_total{service="{{args.service-name}}"}[5m]))  - name: avg-response-time
 successCondition: result[0] <= 0.5
 interval: 5m
 count: 3
 provider:
 prometheus:
 address: http://prometheus.monitoring.svc.cluster.local:9090
 query: |
 avg(rate(http_request_duration_seconds_sum{service="{{args.service-name}}"}[5m]) / 
 rate(http_request_duration_seconds_count{service="{{args.service-name}}"}[5m]))

# prometheus/rules/self-healing-rules.yml
groups:
- name: self-healing
 rules:
 - alert: ServiceHighErrorRate
 expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1
 for: 2m
 labels:
 severity: critical
 automation: restart-pod
 annotations:
 summary: "High error rate detected in {{ $labels.service }}"
 action: "Restart pod to recover from error state"  - alert: ServiceHighMemoryUsage
 expr: container_memory_usage_bytes / container_spec_memory_limit_bytes > 0.9
 for: 5m
 labels:
 severity: warning
 automation: scale-up
 annotations:
 summary: "High memory usage in {{ $labels.pod }}"
 action: "Scale up deployment to handle load"  - alert: ServiceCrashLooping
 expr: rate(kube_pod_container_status_restarts_total[15m]) > 0
 for: 10m
 labels:
 severity: critical
 automation: rollback
 annotations:
 summary: "Pod {{ $labels.pod }} is crash looping"
 action: "Rollback to previous stable version"

#!/bin/bash
# scripts/automated-recovery.sh set -euo pipefail ACTION=$1
SERVICE=$2
NAMESPACE=${3:-default} case $ACTION in
 "restart-pod")
 echo "Restarting pods for service: $SERVICE"
 kubectl rollout restart deployment/$SERVICE -n $NAMESPACE
 kubectl rollout status deployment/$SERVICE -n $NAMESPACE --timeout=300s
 ;;  "scale-up")
 echo "Scaling up service: $SERVICE"
 CURRENT_REPLICAS=$(kubectl get deployment $SERVICE -n $NAMESPACE -o jsonpath='{.spec.replicas}')
 NEW_REPLICAS=$((CURRENT_REPLICAS + 1))
 kubectl scale deployment $SERVICE --replicas=$NEW_REPLICAS -n $NAMESPACE
 ;;  "rollback")
 echo "Rolling back service: $SERVICE"
 kubectl rollout undo deployment/$SERVICE -n $NAMESPACE
 kubectl rollout status deployment/$SERVICE -n $NAMESPACE --timeout=300s
 ;;  *)
 echo "Unknown action: $ACTION"
 exit 1
 ;;
esac # Validate service health after action
sleep 30
kubectl get pods -l app=$SERVICE -n $NAMESPACE
kubectl top pods -l app=$SERVICE -n $NAMESPACE || true echo "Recovery action $ACTION completed for $SERVICE"

# kubernetes/configmaps/feature-flags.yml
apiVersion: v1
kind: ConfigMap
metadata:
 name: wireless-billing-features
 namespace: wireless-billing-prod
data:
 features.yaml: |
 flags:
 new-billing-api:
 enabled: false
 rollout_percentage: 0
 conditions:
 - key: "subscriber_type"
 operator: "equals"
 value: "premium"  enhanced-fraud-detection:
 enabled: true
 rollout_percentage: 25
 conditions:
 - key: "region"
 operator: "in"
 values: ["us-east", "eu-west"]  real-time-analytics:
 enabled: true
 rollout_percentage: 100  overrides:
 development:
 new-billing-api:
 enabled: true
 rollout_percentage: 100
 staging:
 new-billing-api:
 enabled: true
 rollout_percentage: 50

# argo-rollouts/canary-analysis.yml
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
 name: wireless-manager-canary
spec:
 replicas: 10
 strategy:
 canary:
 canaryService: wireless-manager-canary
 stableService: wireless-manager-stable
 trafficRouting:
 nginx:
 stableIngress: wireless-manager-stable
 annotationPrefix: nginx.ingress.kubernetes.io
 additionalIngressAnnotations:
 canary-by-header: X-Canary
 canary-by-header-value: "true"
 analysis:
 templates:
 - templateName: comprehensive-analysis
 startingStep: 2
 args:
 - name: service-name
 value: wireless-manager-canary
 steps:
 - setWeight: 10
 - pause:
 duration: 2m
 - setWeight: 20
 - pause:
 duration: 2m
 - analysis:
 templates:
 - templateName: comprehensive-analysis
 args:
 - name: service-name
 value: wireless-manager-canary
 - setWeight: 50
 - pause:
 duration: 5m
 - setWeight: 75
 - pause:
 duration: 5m
 - setWeight: 100
 - pause:
 duration: 2m ---
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
 name: comprehensive-analysis
spec:
 args:
 - name: service-name
 metrics:
 - name: success-rate
 successCondition: result[0] >= 0.99
 failureCondition: result[0] < 0.95
 interval: 1m
 count: 5
 provider:
 prometheus:
 address: http://prometheus.monitoring.svc.cluster.local:9090
 query: |
 sum(rate(http_requests_total{service="{{args.service-name}}",status=~"2.."}[2m])) /
 sum(rate(http_requests_total{service="{{args.service-name}}"}[2m]))  - name: error-rate
 successCondition: result[0] <= 0.01
 failureCondition: result[0] > 0.05
 interval: 1m
 count: 5
 provider:
 prometheus:
 address: http://prometheus.monitoring.svc.cluster.local:9090
 query: |
 sum(rate(http_requests_total{service="{{args.service-name}}",status=~"5.."}[2m])) /
 sum(rate(http_requests_total{service="{{args.service-name}}"}[2m]))  - name: avg-response-time
 successCondition: result[0] <= 0.5
 failureCondition: result[0] > 1.0
 interval: 1m
 count: 5
 provider:
 prometheus:
 address: http://prometheus.monitoring.svc.cluster.local:9090
 query: |
 avg(rate(http_request_duration_seconds_sum{service="{{args.service-name}}"}[2m]) / 
 rate(http_request_duration_seconds_count{service="{{args.service-name}}"}[2m]))

# .github/workflows/multi-region-deploy.yml
name: Multi-Region Production Deploy on:
 push:
 branches: [main]
 paths: ['**/meta-prod.yml'] jobs:
 deploy-primary-region:
 runs-on: ubuntu-latest
 environment: production-us-central
 steps:
 - name: Deploy to US Central (Primary)
 run: |
 # Deploy to primary region first
 kubectl apply -f wireless-*/meta-prod.yml --context=us-central-prod  # Wait for deployment to stabilize
 for service in wireless-billing wireless-admin wireless-manager; do
 kubectl rollout status deployment/$service -n production --timeout=600s --context=us-central-prod
 done  # Run integration tests
 ./scripts/integration-tests.sh us-central-prod  deploy-secondary-regions:
 needs: deploy-primary-region
 runs-on: ubuntu-latest
 environment: production-global
 strategy:
 matrix:
 region: [eu-west-prod, ap-southeast-prod]
 steps:
 - name: Deploy to {{ matrix.region }}
 run: |
 # Deploy to secondary regions after primary succeeds
 kubectl apply -f wireless-*/meta-prod.yml --context=${{ matrix.region }}  # Wait for regional deployment
 for service in wireless-billing wireless-admin wireless-manager; do
 kubectl rollout status deployment/$service -n production --timeout=600s --context=${{ matrix.region }}
 done  # Regional validation
 ./scripts/regional-validation.sh ${{ matrix.region }}  post-deployment-validation:
 needs: [deploy-primary-region, deploy-secondary-regions]
 runs-on: ubuntu-latest
 steps:
 - name: Global service validation
 run: |
 # Test cross-region connectivity
 ./scripts/cross-region-tests.sh  # Validate load balancing
 ./scripts/load-balancer-validation.sh  # Check monitoring and alerting
 ./scripts/monitoring-validation.sh  - name: Update deployment status
 if: success()
 run: |
 # Update deployment tracking
 curl -X POST "$DEPLOYMENT_WEBHOOK" \
 -H "Content-Type: application/json" \
 -d '{
 "deployment_id": "'$GITHUB_RUN_ID'",
 "status": "success",
 "regions": ["us-central", "eu-west", "ap-southeast"],
 "services": ["wireless-billing", "wireless-admin", "wireless-manager"],
 "timestamp": "'$(date -u -Iseconds)'"
 }'

# prometheus/deployment-metrics.yml
groups:
- name: deployment-metrics
 rules:
 - record: deployment:success_rate
 expr: |
 sum(rate(deployment_attempts_total{result="success"}[1h])) /
 sum(rate(deployment_attempts_total[1h]))  - record: deployment:average_duration_minutes
 expr: |
 avg(deployment_duration_seconds / 60) by (service, environment)  - record: deployment:rollback_rate
 expr: |
 sum(rate(deployment_rollbacks_total[24h])) /
 sum(rate(deployment_attempts_total[24h]))  - alert: HighDeploymentFailureRate
 expr: deployment:success_rate < 0.95
 for: 15m
 labels:
 severity: warning
 team: devops
 annotations:
 summary: "Deployment success rate is below 95%"
 description: "Current deployment success rate: {{ $value | humanizePercentage }}"  - alert: DeploymentTimeoutExceeded
 expr: deployment:average_duration_minutes > 30
 for: 10m
 labels:
 severity: warning
 team: devops
 annotations:
 summary: "Average deployment time exceeds 30 minutes"
 description: "Current average deployment time: {{ $value }} minutes"

#!/bin/bash
# scripts/comprehensive-tests.sh set -euo pipefail SERVICE=$1
ENVIRONMENT=$2
REGION=${3:-us-central} echo "Running comprehensive tests for $SERVICE in $ENVIRONMENT ($REGION)" # Unit tests
echo "Running unit tests..."
if [ -f "$SERVICE/Makefile" ]; then
 cd $SERVICE && make test
else
 echo "No unit tests found for $SERVICE"
fi # Integration tests
echo "Running integration tests..."
./scripts/integration-tests.sh $SERVICE $ENVIRONMENT $REGION # Load tests
echo "Running load tests..."
./scripts/load-tests.sh $SERVICE $ENVIRONMENT $REGION # Security tests
echo "Running security tests..."
./scripts/security-tests.sh $SERVICE $ENVIRONMENT $REGION # API contract tests
echo "Running API contract tests..."
./scripts/contract-tests.sh $SERVICE $ENVIRONMENT $REGION # End-to-end tests
echo "Running E2E tests..."
./scripts/e2e-tests.sh $SERVICE $ENVIRONMENT $REGION echo "All tests completed successfully for $SERVICE"