Connectors

How to connect CloudMonitor to anything you run

Step-by-step setup for every connector we ship, with the exact IAM roles and scopes we require. Everything below is read-only by default. If you’d rather read about what each connector watches before setting it up, the blog has a deep dive per platform.

Overview

Every connector follows the same shape:

  1. You create a least-privilege credential or identity on your side.
  2. You paste an identifier (subscription ID / account ID / cluster URL / API endpoint) into the CloudMonitor onboarding wizard.
  3. The scanner connects, runs a one-time inventory pass (typically 2–5 minutes), and starts the regular polling cadence.
  4. Findings land on your dashboard. You can revoke the credential at any time and the connector degrades gracefully.

Default access is read-only metadata. We never read data-plane contents (object bytes, database rows, secret values, log line bodies) unless you explicitly enable a feature that needs them.

Azure

Path A — Secretless, federated (Beta)

No secret is created, stored or rotated. CloudMonitor publishes one multi-tenant application whose only credential is a federated one trusting CloudMonitor's own scanner identity; you add that application to your directory and grant it read-only roles. Beta — not yet validated against a live customer tenant. Path B is the one known to work today. On a deployment where the secretless connection has not been set up, the wizard says so instead of showing these values.

1
Copy CloudMonitor's application (client) ID from the onboarding wizard. You do not create an app registration, a secret or a certificate.
2
Add the application to your directory: az ad sp create --id <cloudmonitor-app-id>. This creates a service principal for it in your tenant — an enterprise application you can inspect, restrict or delete at any time.
3
Grant the roles to that service principal at the scope you want monitored — subscription, management group, or resource group:
SP_OID=$(az ad sp show --id <cloudmonitor-app-id> --query id -o tsv)
az role assignment create --assignee-object-id $SP_OID --assignee-principal-type ServicePrincipal --role Reader --scope /subscriptions/<sub-id>
az role assignment create --assignee-object-id $SP_OID --assignee-principal-type ServicePrincipal --role "Key Vault Reader" --scope /subscriptions/<sub-id>
az role assignment create --assignee-object-id $SP_OID --assignee-principal-type ServicePrincipal --role "Monitoring Reader" --scope /subscriptions/<sub-id>
4
Enter your tenant ID and subscription ID in CloudMonitor (Azure → Subscriptions → Secretless). Nothing secret is entered. Exposure findings arrive within the hour and expiry and rotation findings with the next nightly scan; if the token exchange is refused, the subscription shows the error.
How it works: the scanner exchanges its managed-identity token for a short-lived token in your tenant (Microsoft Entra workload identity federation). Microsoft requires the application and the identity it trusts to live in the same directory, which is why the application is ours and not one you create. RBAC scope is exactly what you grant, and every read is in your activity log. See the auth-method comparison.

Path B — Service principal with a client secret (works today)

1
Create an Entra app registration and a client secret: az ad sp create-for-rbac --name cloudmonitor-reader --skip-assignment. CloudMonitor accepts a client secret; certificate credentials are not supported yet. Azure caps a secret's life at two years — note the expiry.
2
Grant Reader, Key Vault Reader and Monitoring Reader at the scope you want monitored (same commands as Path A, using your service principal's object ID).
3
Enter the tenant ID, client ID and secret in CloudMonitor. The secret is encrypted before it is stored (AES-256-GCM) under an application-level key held outside the database, and is never shown again.

What permissions we ask for, and why

  • Reader on the target scope — lets us list resources and read their properties.
  • Monitoring Reader on the target scope — lets us query Azure Monitor metrics and the activity log.
  • Optional: Cost Management Reader at the billing-scope — required for the cost engine.
  • Optional: directory scanning (Microsoft Entra ID) — guest accounts, inactive accounts, users with no MFA, privileged roles, expiring app secrets and SAML signing certificates, Microsoft 365 subscription renewals, plus the tenant's Conditional Access and admin-role posture against the CIS Microsoft 365 benchmark, app consent risk, and Microsoft 365 license waste with an estimated monthly cost. It needs these read-only Microsoft Graph application permissions, which a directory admin grants. Grant only the ones you want: each is independent, and leaving one out switches off just the findings listed beside it. When a permission is missing the scan still runs and the subscription's status says which one:
    • Directory.Read.All — guest accounts and accounts whose password never expires, plus the user list behind the inactive-account check; delegated permissions users and admins have consented to; Microsoft 365 license counts and each user's licenses (license waste); and each Microsoft 365 subscription's status and renewal date.
    • AuditLog.Read.All — inactive accounts (last sign-in), users with no MFA method registered, administrators with weak MFA methods, subscription Owners with no MFA, apps with no recent sign-in, licensed users with no recent sign-in, and PIM-eligible admin roles nobody has activated (from the directory audit log, P2). Sign-in and MFA data need a Microsoft Entra ID P1 or P2 license, and Microsoft asks for this permission to be granted together with Directory.Read.All.
    • RoleManagement.Read.Directory — privileged role assignments such as Global Administrator, whether each is permanent or eligible in Privileged Identity Management (P2), and the Global Administrator count. Directory.Read.All also covers the assignment list.
    • Application.Read.All — app-registration client secrets and certificates that are expiring or expired, the active SAML signing certificate of each enterprise application, the permissions each app holds (high-risk permissions, unverified publishers), and app registrations with no owner. Directory.Read.All also covers this read.
    • Policy.Read.All — security defaults and Conditional Access policies: MFA for all users and for administrators, legacy authentication, risk-based policies (P2), break-glass exclusions and policies left in report-only mode; and whether users can consent to or register applications. Nothing else covers these reads.
    • DeviceManagementServiceConfig.Read.All — only for tenants that use Microsoft Intune with Apple devices: when the Apple MDM push certificate, volume-purchase (VPP) tokens and Automated Device Enrollment tokens expire. Expiry dates only; no device, user or token data is read. A tenant without Intune is never asked for it.
    • SecurityEvents.Read.All — your Microsoft 365 Secure Score: the current score and the maximum, once a day, so the trend and the change over 30 days can be shown on the Directory tab and in the client report. Only the two numbers are read and stored; no security alerts, controls or user data.
    • ServiceHealth.Read.All — Microsoft 365 Service Health: the incidents and advisories Microsoft currently reports for the services your tenant uses (Exchange Online, Teams, SharePoint, Entra and so on), checked every 5 minutes on a paid plan (every 15 during a trial) so an outage is mailed to you instead of reaching you as a phone call. Service status only; no mailbox, message or user data.
    • ServiceMessage.Read.All — Microsoft 365 Message Center: announcements of feature retirements and major changes, counted down to their action-required date. The announcement text itself is not read or stored; no mailbox, message or user data.

    The findings appear in CloudMonitor under Findings → Azure → Directory. Until the grant is in place that tab says so, and names what it is still waiting for.

What we read in detail

The Azure connector deep-dive blog post enumerates every signal, by section: compute, storage, networking, identity, cost, activity log.

AWS Beta

Beta. The AWS scanners are verified against emulated AWS APIs; not yet validated on a live customer account.

Read-only IAM user with a metadata-only policy (what works today)

This setup uses an access key for a dedicated IAM user that you create and can delete at any time. The key is stored encrypted at rest (AES-256-GCM). A cross-account role with an external ID — no long-lived key at all — is the other method. The onboarding wizard's IAM role option shows whether it is available on this service yet.

1
Create a dedicated IAM user for CloudMonitor with programmatic access only — no console password.
2
Attach the metadata-only policy shown in full in the onboarding wizard. It is derived from what the scanners actually call and contains no data-plane reads — no s3:GetObject, no DynamoDB item reads, no secretsmanager:GetSecretValue. The AWS-managed SecurityAudit policy is the broader alternative. Do not attach ReadOnlyAccess: it can read your data, and we do not need it.
3
Paste the access key ID and secret into the wizard, which runs a connectivity test. Rotate or delete the key in IAM whenever you like — we simply stop being able to scan.

Planned, not available yet: cross-account role (abridged)

Resources:
  CloudMonitorReadOnlyRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: CloudMonitorReadOnly
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal: { AWS: arn:aws:iam::<cm-aws-account>:root }
            Action: sts:AssumeRole
            Condition:
              StringEquals: { sts:ExternalId: <your-external-id> }
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/SecurityAudit
        - arn:aws:iam::aws:policy/job-function/ViewOnlyAccess
      Policies:
        - PolicyName: CloudMonitorCostAndRecommender
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - ce:GetCostAndUsage
                  - ce:GetCostForecast
                  - ce:GetAnomalies
                  - compute-optimizer:Get*
                  - trustedadvisor:Describe*
                Resource: "*"

What we read in detail

See the AWS connector deep-dive.

GCP

Path A — Keyless, Workload Identity Federation (Beta)

No key is created, stored or rotated. A workload identity pool in your project trusts CloudMonitor's identity provider, and CloudMonitor uses a read-only service account through it. Beta — not yet validated against a live customer project. A service-account key (below) also works. On a deployment where keyless connection has not been set up, the wizard says so instead of showing these steps.

1
Create a workload identity pool and provider by running the setup script the wizard shows.
2
Create a service account and grant it eight read-only roles: roles/viewer, roles/iam.securityReviewer, roles/secretmanager.viewer, roles/servicehealth.viewer, roles/monitoring.viewer, roles/recommender.viewer, roles/orgpolicy.policyViewer and roles/cloudasset.viewer.
3
Allow CloudMonitor's federated identity to impersonate the service account.
4
Paste the Workload Identity provider name and the service-account email into the wizard.

Path B — Service-account key file

Create a service account with eight read-only roles (roles/viewer, roles/iam.securityReviewer, roles/secretmanager.viewer, roles/servicehealth.viewer, roles/monitoring.viewer, roles/recommender.viewer, roles/orgpolicy.policyViewer and roles/cloudasset.viewer), generate a JSON key, and upload it in the wizard. We store it encrypted at rest (AES-256-GCM), and you can delete the key in your project at any time.

Multi-project / org-wide

Grant the same eight roles at the organization or folder scope and we'll auto-discover all projects within it.

What we read: GCP connector deep-dive.

Kubernetes

The manifest

Two ways in. Managed clusters — AKS, EKS and GKE — are read through the cloud provider's management API using the cloud connection you already have; nothing is installed in the cluster. Any distribution — OpenShift, k3s, kind, self-hosted, and managed clusters too — can be connected with the read-only manifest below (Beta: tested against a simulated API server, not yet run against a production cluster). The second way needs an API server CloudMonitor can reach from the public internet.

Show the manifest
apiVersion: v1
kind: ServiceAccount
metadata:
  name: cloudmonitor-reader
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cloudmonitor-reader
rules:
  - apiGroups: [""]
    resources: ["nodes", "namespaces", "pods", "serviceaccounts", "resourcequotas"]
    verbs: ["get", "list"]
  - apiGroups: ["apps"]
    resources: ["deployments", "statefulsets", "daemonsets"]
    verbs: ["get", "list"]
  - apiGroups: ["networking.k8s.io"]
    resources: ["ingresses", "networkpolicies"]
    verbs: ["get", "list"]
  - apiGroups: ["rbac.authorization.k8s.io"]
    resources: ["clusterrolebindings", "rolebindings", "clusterroles", "roles"]
    verbs: ["get", "list"]
  - apiGroups: ["cert-manager.io"]
    resources: ["certificates"]
    verbs: ["get", "list"]
  - apiGroups: ["velero.io"]
    resources: ["backups", "schedules"]
    verbs: ["get", "list"]
  - apiGroups: ["metrics.k8s.io"]
    resources: ["pods", "nodes"]
    verbs: ["get", "list"]
  - nonResourceURLs: ["/version"]
    verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: cloudmonitor-reader
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cloudmonitor-reader
subjects:
  - kind: ServiceAccount
    name: cloudmonitor-reader
    namespace: kube-system
---
apiVersion: v1
kind: Secret
metadata:
  name: cloudmonitor-reader-token
  namespace: kube-system
  annotations:
    kubernetes.io/service-account.name: cloudmonitor-reader
type: kubernetes.io/service-account-token

Notice what's not in the rules list: secrets, configmaps, pod logs, exec, watch, or any write verb. The scanner only issues get and list on the resources above, so that is all the role grants. Ingress TLS secret names are read from the Ingress object; the Secret itself is never fetched.

Connecting

Apply the manifest, read the token with kubectl -n kube-system get secret cloudmonitor-reader-token -o jsonpath='{.data.token}' | base64 -d, and enter the API server URL (https only), the token and — if your API server uses a private CA — its CA certificate in the Kubernetes onboarding wizard. TLS verification is always on; there is no “skip verification” option. The token and CA are encrypted before they are stored and are never displayed again. Checks: Kubernetes version against upstream end-of-life, node readiness and pressure, kubelet version skew, unavailable workloads, CrashLoopBackOff / image-pull failures / restart counts, :latest or untagged images, missing memory limits, privileged / host-namespace / hostPath workloads, namespaces with no NetworkPolicy, Ingress TLS coverage, and cert-manager certificate expiry. Clusters are scanned every hour — cluster and workload state is exactly the kind of thing that changes between one nightly pass and the next. To revoke access, delete the ServiceAccount or remove the connection in CloudMonitor.

Private clusters

A cluster whose API server is not reachable from the public internet cannot use the in-cluster connector: CloudMonitor's scanner refuses private, loopback and link-local addresses by design. If it is an AKS, EKS or GKE cluster it is still covered at the management-API level (version, node pools, upgrade and configuration findings). For everything else there is the CloudMonitor agent (Beta): one small Deployment you run in the cluster that reads it with the same get-and-list-only ClusterRole and pushes the findings to CloudMonitor over HTTPS, so nothing ever connects into your network. The agent image is private — your cluster pulls it from CloudMonitor with a per-cluster credential that you can rotate or revoke at any time, and the manifest pins it by digest.

What we read: Kubernetes connector deep-dive.

MuleSoft Anypoint

1
Create a connected app in Anypoint: Access Management → Connected Apps → App acts on its own behalf (Client Credentials).
2
Grant scopes per environment you want monitored: Read Organization, Read Servers, Read Applications, Read APIs Configuration, Manage API Read. (We list the exact scope names in the wizard.)
3
Copy the client ID and client secret into the CloudMonitor wizard, along with the org ID and the environments you want included.

What we read: MuleSoft connector deep-dive.

Docker

Two kinds of Docker connection, both read-only and scanned on a schedule (hourly for exposure, nightly for everything): a container registry and a Docker Engine host. CloudMonitor never pushes, pulls layers, creates, starts, stops, kills, or execs anything.

1
Registries. Add Docker Hub (namespace + a read-only personal access token), GitHub Container Registry (owner + a token with read:packages), or a self-hosted registry by its https URL (registry:2, Harbor, Nexus, Artifactory, GitLab, Quay; optional read-only credentials). We flag images anyone can pull without credentials, :latest tags older than a year, and Docker Hub access tokens with no expiry. Docker Hub, GHCR and plain Registry v2 publish no vulnerability results; each image says so rather than reading as clean. Docker Hub and GHCR are in Beta (not yet validated on a live customer account). ACR, ECR and GAR registries are supported on request.
2
Docker hosts. Expose the Engine API over TCP with mutual TLS per Docker's own Protect the Docker daemon socket guide, allow our scanner to reach port 2376, and paste all three (CA, client certificate, client key) into the connector. There is no "trust any client" mode. The host must be on a public address: private, internal and Unix-socket-only daemons cannot be reached from our scanner, and an agent for air-gapped hosts is not built yet.
3
On a connected host we flag containers running as root, restart loops, images older than 90 days, an unbounded log driver (no max-size), --privileged mode, --network host, and sensitive ports (databases, SSH, RDP, and similar) published to a non-loopback address.

What we read: Docker connector deep-dive.

SaaS platforms

GitHub and Cloudflare are connectable now, in Beta. The other platforms below are coming soon — this section documents their planned scope so you know what's next. Contact us to be notified as each one ships.

All SaaS connectors follow the same shape: create a least-privilege API token on the SaaS, paste it into the wizard. Below is the scope we ask for, by platform.

  • Cloudflare — a scoped API token, all Read: Zone and SSL and Certificates (required), plus Zone WAF, DNS, Workers Scripts, Cloudflare Pages, Workers R2 Storage and D1 (optional; the account-level ones need your Account ID). Zones, SSL certificate expiry, WAF status, dangling CNAME records, and Workers, Pages, R2 and D1 inventory. In Beta (not yet validated on a live customer account).
  • PagerDuty — read-only General Access REST API key. (Coming soon.)
  • Datadog — an Application Key paired with an API key, both read-only via a custom role. (Coming soon.)
  • GitHub — a fine-grained personal access token, all read-only: Metadata, Actions, Administration, Code scanning alerts, Dependabot alerts and Secret scanning alerts. Branch protection, open security alerts, deploy keys, token expiry, and CI/CD pipeline health (failing, stuck and flaky workflows on the default branch). In Beta (not yet validated on a live customer account).
  • Okta — OAuth scope okta.users.read, okta.apps.read, okta.logs.read, okta.groups.read, or a read-only Admin role. (Coming soon.)
  • HashiCorp Vault — policy with list + read on sys/* only. (Coming soon.)
  • MongoDB Atlas — Project Read Only API key, scoped per project. (Coming soon.)
  • Vercel — token with read access to the team. (Coming soon.)
  • Terraform Cloud — team token with read access to workspaces. (Coming soon.)
  • Stripe (operational mode) — restricted key with read on charges/refunds/disputes/webhooks counts only. We do not request customer-list or PaymentMethod scope. (Coming soon.)
  • DigitalOcean — Personal Access Token scoped to read-only. (Coming soon.)
  • Fly.io — org-scoped token with read access to apps, machines, and volumes. (Coming soon.)
  • Hetzner Cloud — Project-scoped API token with read-only permissions. (Coming soon.)
  • Alibaba Cloud — AccessKey pair restricted to a read-only custom RAM policy (ECS/OSS/RAM describe-and-list actions only). (Coming soon.)
  • IBM Cloud — IAM API key with Viewer role on VPC, Cloud Object Storage, and IAM Identity Service. (Coming soon.)
  • Netlify — Personal Access Token, issued from a least-privilege team member (Netlify has no scoped/read-only PAT). (Coming soon.)
  • Heroku — read-only Platform API token (OAuth read scope, or a Personal API Key from a least-privileged collaborator). (Coming soon.)
  • Railway — a Project Token scoped to one project, or an account-wide API token from a least-privileged account. (Coming soon.)
  • OpenStack — Keystone v3 application credential with the reader role only, on a cloud whose Keystone endpoint is reachable from the internet. (Coming soon.)
  • HashiCorp Nomad — ACL token bound to a read-only policy (namespace read, node read, agent read), plus your cluster's public address. (Coming soon.)
  • Tencent Cloud — SecretId and SecretKey of a CAM sub-user with a read-only policy. (Coming soon.)
  • Huawei Cloud — access key pair of an IAM user with read-only access. (Coming soon.)
  • UpCloud — API token, or an API sub-account with the minimum access (UpCloud has no read-only token scope). (Coming soon.)
  • Exoscale — IAM API key and secret whose role can only list and get resources. (Coming soon.)
  • Civo — API key from a dedicated team member (Civo has no read-only or scoped key). (Coming soon.)
  • IONOS Cloud — token from the token manager, created by a user in a group with read privileges only. (Coming soon.)
  • STACKIT — service account key (JSON) with a read-only role on the project. (Coming soon.)
  • Gcore — permanent API token created by a user with a read-only (Viewer) role. (Coming soon.)
  • Contabo — API client ID and secret, plus an API user whose role can only read. (Coming soon.)
  • Kamatera — API client ID and secret from a dedicated user (Kamatera has no read-only API client). (Coming soon.)
  • Rackspace — a Rackspace Spot refresh token, or a Rackspace Cloud username and API key from a separate user (neither can be limited to read-only). (Coming soon.)
  • phoenixNAP Bare Metal Cloud — client ID and secret of an API client with a read-only role, where the portal offers one. (Coming soon.)
  • Latitude.sh — API key created with Read-only switched on. (Coming soon.)
  • Leaseweb — API key from a least-privilege user (Leaseweb keys are not scoped). (Coming soon.)
  • Backblaze B2 — Read Only application key (key ID and application key). (Coming soon.)
  • Wasabi — access key and secret of an IAM user whose policy only lists and reads buckets and users. (Coming soon.)
  • Koyeb — API token for a dedicated least-privilege member (Koyeb tokens cannot be limited to read-only). (Coming soon.)
  • Northflank — API token created with a role that can only read. (Coming soon.)
  • Upsun / Platform.sh — API token from a user with read-only access to the projects you want monitored. (Coming soon.)

What we read per platform: SaaS connectors deep-dive.

Custom & on-prem connectors

If a system has an authenticated API, we can connect to it. See Custom connectors for the menu of patterns and how to request a custom integration.

Auth method comparison

If you’re deciding between Managed Identity, Service Principal, SAS token, or wrapping in Key Vault, the full comparison post has the cheat sheet. TL;DR: prefer MI / federated identity wherever the caller can run inside your cloud, fall back to SP / cross-account-role with external ID otherwise, and treat SAS tokens as a single-purpose tool not a general auth strategy.