ArgoCD Roles Permissions

Published
Length
3 min read

Luis Felipe Dias

All posts

You set up argocd roles permissions by writing policy rules and binding them to groups. These rules define which users can view, sync, or delete apps inside a project. Most teams start by linking their identity provider groups to default built-in roles. When these roles are too broad, any developer can trigger a sync in production. Overly wide grants also let users alter project settings or remove live resources. How argocd roles permissions work in practice The platform uses role-based rules

Your coding agents run with your access.

Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.

You set up argocd roles permissions by writing policy rules and binding them to groups. These rules define which users can view, sync, or delete apps inside a project. Most teams start by linking their identity provider groups to default built-in roles. When these roles are too broad, any developer can trigger a sync in production. Overly wide grants also let users alter project settings or remove live resources.

How argocd roles permissions work in practice

The platform uses role-based rules to control what users and groups can do. Admins define these rules in a central policy map or within specific projects. Every rule links a subject, a resource type, an action, and a target object. The subject is a user, a local account, or a group from single sign-on.

Resources include apps, clusters, repos, projects, accounts, and logs. Actions cover verbs like get, create, update, delete, sync, override, and action. Built-in roles offer a starting point for most engineering teams. A read-only role lets users view app status and settings across the platform. An admin role grants full control over every resource and cluster setting.

Custom roles let you narrow these grants down to single projects or namespaces. You can allow a team to sync staging apps while keeping production read-only. You can also set a default fallback role for anyone who logs in. If a user belongs to multiple groups, the engine checks each rule in order. Explicit deny rules take priority over allow rules when conflicts happen.

Managing project-scoped roles and SSO groups

Global rules work well for platform admins who manage the whole control plane. For product teams, project-scoped roles keep daily work isolated and tidy. Each project acts as a boundary around a set of apps and target clusters. Project admins can create roles that apply only to resources inside that boundary.

Teams map external identity groups to these project roles through token claims. When an engineer logs in, the identity provider sends their group list in a token. The control plane reads those groups and applies the matching project rules right away. Project roles can also generate tokens for automated pipelines to trigger deployments. This setup keeps team grants separate without editing the global policy file every day.

Lambda Execution Roles + ArgoCD Security: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

What native roles solve and where gaps remain

Native role checks solve the problem of who can trigger actions in the tool. They stop unauthorized users from clicking sync or deleting an app in the dashboard. They also help teams split duties between staging projects and production projects.

Still, static role rules only check who starts a request at the front door. Once a role grants update, exec, or override rights, every action under it runs. The role system does not inspect live shell commands inside a running pod container. It also does not require peer approval for a single high-risk sync or override. Also, shared automation tokens often hold broad permissions that stay active for months. If someone leaks a project token, an attacker gains full control over those apps. Native logs show which role made a call, but not what happened inside shells.

Govern kubectl and API calls in flight

Identity providers and Kubernetes RBAC decide who logs into a cluster. They cannot redact keys inside returned JSON objects or hold a risky delete call for review. By design, hoop.dev runs as an open-source proxy, a sidecar for your Kubernetes API, checking requests and responses without replacing RBAC.

First, hoop.dev guardrails refuse banned methods, paths, or headers before they run. Next, hoop.dev data masking rewrites sensitive keys in returned Secret, ConfigMap, and log responses in memory, and writes each decision to the audit trail. Explore the repo on GitHub.

Frequently asked questions

How does the platform handle conflicting allow and deny rules?

The policy engine evaluates deny rules before allow rules for the same resource. If a user matches both an allow rule and a deny rule, the deny wins.

What is the difference between global roles and project roles?

Global roles apply across the entire control plane and manage clusters, repos, and apps. Project roles apply only to apps and actions within one specific project boundary.

Can we restrict a role to only sync a single app?

Yes, you can scope a policy rule to a specific project and app name. This lets a group run the sync action on one app without touching others.

The query runs. The emails stay hidden.