tutorial

Monitoring Acorn with Vigilmon: API Server Health, App Status, Registry Availability & Deployment Heartbeats

How to monitor Acorn (application packaging and deployment for Kubernetes) with Vigilmon — API server health checks, app deployment status, image registry availability, SSL certificate monitoring, and deployment pipeline heartbeats.

Acorn is an application packaging and deployment tool for Kubernetes that simplifies complex, multi-container deployments using Acornfiles — a single-file application descriptor that handles images, volumes, secrets, and service dependencies in a developer-friendly format. As the deployment control plane for Acorn-packaged applications, the Acorn API server manages app lifecycle, the image registry provides Acorn image distribution, and the runtime syncs desired state to Kubernetes resources. An unavailable Acorn API server blocks all app deployments and updates, a degraded image registry prevents new Acorn images from pulling, and a broken runtime reconciler leaves apps stuck in a pending state indefinitely. Vigilmon gives you external visibility into the Acorn API server health, app deployment availability, image registry status, SSL certificates, and deployment pipeline heartbeats so you catch failures before they stall your teams' application deployments.

What You'll Build

  • A monitor on the Acorn API server health endpoint
  • An app status availability check via the Acorn REST API
  • An image registry availability check via keyword matching
  • SSL certificate monitoring for the Acorn API endpoint
  • A heartbeat monitor confirming scheduled deployment pipeline jobs complete on time

Prerequisites

  • A running Acorn installation with the Acorn API server exposed at a URL
  • Acorn API accessible over HTTPS (via an Ingress or LoadBalancer)
  • A free account at vigilmon.online

Step 1: Verify the Acorn API Server Health Endpoint

The Acorn API server exposes a readiness endpoint confirming the server is operational:

curl https://acorn.example.com/healthz

A healthy Acorn API server returns:

ok

This confirms the Acorn API server pod is alive and its internal routing is responding.

Step 2: Create a Vigilmon HTTP Monitor for the Acorn API

  1. Log in to Vigilmon → Add Monitor → HTTP.
  2. URL: https://acorn.example.com/healthz.
  3. Check interval: 60 seconds.
  4. Response timeout: 10 seconds.
  5. Expected status: 200.
  6. Keyword: ok.
  7. Label: Acorn API Server Health.
  8. Click Save.

Set alerts to trigger after 1 consecutive failure — an Acorn API outage blocks all app deployments, updates, and secret management operations for every team using the platform.

Step 3: Monitor the Acorn API Root

Beyond the health check, the Acorn API root confirms the API server is serving application resources and not just passing a shallow health probe:

curl https://acorn.example.com/apis/api.acorn.io/v1 \
  -H "Authorization: Bearer your-token"

A healthy response returns an API discovery document with available resource kinds. Add a monitor:

  1. Add Monitor → HTTP.
  2. URL: https://acorn.example.com/apis/api.acorn.io/v1.
  3. Check interval: 2 minutes.
  4. Expected status: 200.
  5. Keyword: resources.
  6. HTTP Headers: Authorization: Bearer your-token.
  7. Label: Acorn API Discovery.
  8. Click Save.

Authentication: Acorn uses kubeconfig-based token authentication. Generate a token via acorn login and use it in the Authorization header.

Step 4: Monitor Application Deployment Status

Acorn's app list endpoint confirms the runtime is reconciling applications and the API database layer is healthy. A healthy response lists managed apps; an empty cluster returns an empty array:

curl https://acorn.example.com/apis/api.acorn.io/v1/namespaces/acorn/apps \
  -H "Authorization: Bearer your-token"

A healthy response includes:

{"items":[],"kind":"AppList","apiVersion":"api.acorn.io/v1"}

Add a monitor:

  1. Add Monitor → HTTP.
  2. URL: https://acorn.example.com/apis/api.acorn.io/v1/namespaces/acorn/apps.
  3. Check interval: 2 minutes.
  4. Expected status: 200.
  5. Keyword: AppList.
  6. Label: Acorn App List.
  7. Click Save.

Step 5: Monitor the Acorn Image Registry

Acorn packages applications as OCI images stored in an Acorn image registry. When the registry is unreachable, new app deployments fail to pull their Acorn images and existing apps cannot be updated:

curl https://acorn-registry.example.com/v2/

A healthy OCI-compliant registry returns:

{}

With HTTP 200. Add a monitor:

  1. Add Monitor → HTTP.
  2. URL: https://acorn-registry.example.com/v2/.
  3. Check interval: 5 minutes.
  4. Expected status: 200.
  5. Label: Acorn Image Registry.
  6. Click Save.

Note: If using the hosted Acorn registry at ghcr.io or index.docker.io, monitor those registry health endpoints instead. The GitHub Container Registry exposes https://ghcr.io/v2/ as a reachability check.

Step 6: Set Up Deployment Pipeline Heartbeat Monitoring

CI/CD pipelines that build and deploy Acorn images can silently fail if the image push succeeds but the Acorn app update fails to propagate. Use Vigilmon heartbeat monitoring to confirm deployment pipelines complete on schedule:

Step 6a — Create a Heartbeat monitor in Vigilmon:

  1. Add Monitor → Heartbeat.
  2. Name: Acorn production deploy pipeline.
  3. Expected interval: 24 hours (or match your pipeline schedule).
  4. Grace period: 30 minutes.
  5. Copy the generated ping URL (e.g., https://vigilmon.online/ping/abc123).

Step 6b — Add a ping step to your CI/CD pipeline:

# GitHub Actions example
- name: Build and push Acorn image
  run: |
    acorn build -t acorn-registry.example.com/my-org/my-app:${{ github.sha }} .
    acorn push acorn-registry.example.com/my-org/my-app:${{ github.sha }}

- name: Deploy to production
  run: |
    acorn run --name my-app \
      acorn-registry.example.com/my-org/my-app:${{ github.sha }}
    acorn wait --name my-app --timeout 5m

- name: Notify Vigilmon
  run: curl -fsS -m 10 https://vigilmon.online/ping/abc123

If the pipeline fails before reaching the ping step, Vigilmon fires an alert after the grace period expires, ensuring silent deployment failures are surfaced.

Step 7: Monitor SSL Certificates

Acorn's API server and image registry are consumed by developer CLI tooling and CI/CD pipelines. An expired certificate breaks all automated deployment operations:

  1. Add Monitor → SSL Certificate.
  2. Domain: acorn.example.com (your Acorn API domain).
  3. Alert when expiry is within: 30 days.
  4. Alert again at: 14 days, 7 days, 3 days, 1 day.
  5. Click Save.

Repeat the same monitor for acorn-registry.example.com if you host your own Acorn image registry.

Step 8: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | Action | |---|---|---| | API server health | Non-200 or ok missing | Check Acorn controller pod; kubectl get pods -n acorn-system | | API discovery | Non-200 or resources absent | API server degraded; app CRUD operations blocked | | App list | Non-200 or AppList absent | Runtime reconciler issue; apps may be stuck pending | | Image registry | Non-200 | Registry unreachable; new deploys and updates blocked | | Deploy heartbeat | No ping within window | Pipeline failed; check build and deployment logs | | SSL certificate | < 30 days | Renew; verify cert-manager TLS config |

Common Acorn Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Acorn API server pod crash | Health endpoint unreachable; alert within 60 s | | API server DB connection failure | App list returns 500; alert immediately | | Image registry connectivity lost | Registry monitor fires; app image pulls fail | | Runtime reconciler stalls | App list API degrades; apps stuck in pending | | Deploy pipeline silently fails | Heartbeat monitor alerts after grace period | | SSL certificate expires | SSL monitor alerts at 30-day threshold | | Acorn token expired in CI | API monitors return 401; alert immediately | | Namespace quota exceeded | App creation fails; API returns 403; alert fires |

Acorn's single-file application model abstracts away Kubernetes complexity — but that abstraction depends entirely on the API server, runtime reconciler, and image registry working together. A silent failure in any one component leaves apps stuck in an indeterminate state without triggering application-level errors visible to developers. Vigilmon's layered monitoring of the API server health, app list availability, image registry status, deployment heartbeats, and SSL certificates gives you external visibility across every layer of Acorn's application delivery stack, so you catch failures before they block your teams' deployments.

Start monitoring Acorn in under 5 minutes — register free at vigilmon.online.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles