How to plan an Argo CD 3.0 to 3.1 upgrade on your own clusters
If your Argo CD 3.0 instance deploys to clusters you control, the move to 3.1 changes four areas: the server-side OIDC authorization code flow and its callback redirect URI, the deprecated v1 resource actions API, symlink checks on the --staticassets directory, and project API responses, which no longer include project-scoped repository and cluster credentials. The supported path is a direct minor upgrade from 3.0 to 3.1, provided you read the 3.0 to 3.1 upgrade notes before you change anything. Treat the upgrade as a planned change with its own test instance, rollback point and sign-off, not as a routine image bump.
Argo CD ships a minor release four times a year, roughly once every three months, and only the three most recent minor versions receive patch releases. That cadence sets your planning horizon. Confirm where 3.0 and 3.1 sit in the current patch window on the Argo CD release process page and check the argoproj/argo-cd releases page for the patch level you should target. If 3.0 has already fallen out of the patch window, the upgrade becomes more urgent, and the cost of waiting grows with each new minor release.
Start by inventorying what touches each change. Search your Ingress, reverse proxy and identity provider configuration for the /auth/callback redirect URI, and identify whether enablePKCEAuthentication is set, since only that setting adds the new URI requirement. Search your automation, dashboards and scripts for calls to the v1 resource actions endpoint so you can move them to the v2 path before the deprecated one is removed. Confirm whether any custom static assets are mounted from a path that uses symlinks. Finally, check whether anything reads project-scoped credentials from API responses. Each item is a concrete check that a reviewer can sign off.
Which 3.1 changes affect your installation
This table lists the five 3.1 changes most likely to affect a running Argo CD 3.0 installation, with the impact of each and the action to take before cutover. Read each row against your own identity setup, scripts and dashboards, because the effect depends on how your team uses the API and the UI. Most teams will need to act on at least the OIDC callback and the v1 actions API, while the health check change mainly affects how applications report status.
| Change | Impact | Action needed |
|---|---|---|
| OIDC authorization code flow handled by the server, with /auth/callback when PKCE is enabled | If enablePKCEAuthentication is set, sign-in fails until the callback endpoint is registered with the identity provider | Add the /auth/callback redirect URI to the OIDC client, then test sign-in in a non-production instance first |
| Deprecation of the v1 resource actions API | Scripts or clients calling the v1 endpoint still work for now but are flagged for removal in a future release | Search automation for the v1 path and move calls to the v2 resource actions endpoint |
| 500 error for out-of-bounds symlinks in the --staticassets directory | Requests that resolve to symlinks pointing outside the static assets directory now return an error | Check custom UI assets for symlinks that point outside the directory and replace or relocate them |
| Removal of project-scoped repository and cluster credentials from project API responses (GHSA-786q-9hcg-v9ff) | Tools that read credentials through project API responses will receive fewer fields, which can break integrations | Confirm with your team whether any client depends on those fields and update it to read credentials from their source |
| Built-in health checks for CRDs, including Gateway API, RabbitMQ, CloudNativePG and OpenTelemetry Collector | Applications using these resources may change health status after upgrade, which can alter dashboards and alerts | Review affected applications after the upgrade and confirm alert thresholds and status-based automation still match expected behavior |
Why the OIDC redirect URI needs an update before cutover
In Argo CD 3.1, the server handles the OIDC authorization code flow whether or not PKCE is enabled. If you use PKCE, the /auth/callback endpoint must be added to the redirect URIs registered on your identity provider's OIDC client before you upgrade. Without it, the identity provider will refuse to send users back to Argo CD after they authenticate, so SSO logins fail at the point of return. The failure appears only after the upgrade, which is why it is easy to miss in a test that only checks the login page loads.
Ask the identity provider administrator for the current redirect URI list on the Argo CD client before the change window opens. Confirm that every Argo CD hostname in use, including any staging or secondary instance that shares the client, has the /auth/callback path added alongside the existing entries. Check that the URI matches your Argo CD external URL exactly, including scheme and path, because a mismatch fails the same way a missing entry does. Record the change request and the administrator who confirmed it, and test one SSO login against a non-production instance that uses the same client configuration before cutover.
Keep the built-in admin user available as a break-glass path during the upgrade. The user management guidance recommends using the admin account only for initial setup and disabling it with admin.enabled set to false once local users or SSO are configured. Before you disable it, confirm that at least one SSO or local account has the administrator role in your RBAC policy, and that someone can reach the cluster and reset the admin password if the redirect change goes wrong. Check the Argo CD user management documentation for the current steps before you change that setting during the upgrade.
What to back up and inventory before moving to 3.1
These six items cover what you can restore, what will break and what you must test before changing the running version. Each one maps to a 3.1 change in the upgrade notes or to a state Argo CD keeps in Kubernetes objects. Work through them in order, because the backup and the rehearsal depend on the inventory.
Back up Argo CD objects and settings
Export every Application, AppProject and Secret object in the Argo CD namespace, along with the argocd-cm and argocd-rbac-cm ConfigMaps. Argo CD keeps its state in Kubernetes objects, so these exports are your restore path if the upgrade goes wrong. Store them outside the cluster and confirm you can apply them to a scratch namespace. Check that repository and cluster credentials are included, since they are stored as Secrets.
Inventory v1 resource actions callers
Search your scripts, CI jobs, runbooks and internal tools for calls to the v1 resource actions endpoint under /api/v1/applications. Argo CD 3.1 deprecates that API in favor of the v2 path. Record the owner, the action called and the pipeline that runs it, so each caller can be moved to the v2 endpoint and retested before cutover. Do not rely on a single code search, because some callers live in external automation.
List static asset customizations and symlinks
If you serve custom UI assets through the --staticassets directory, list every file and check each one for symbolic links. Argo CD 3.1 returns a 500 error for symlinks that point outside that directory. Fix or flatten any out-of-bounds links in your source before the upgrade, then confirm the UI still loads the custom assets in the rehearsal environment.
Record SSO client settings and redirect URIs
Export the current OIDC client configuration for Argo CD from your identity provider, including redirect URIs, scopes and any PKCE setting. With enablePKCEAuthentication set, the /auth/callback endpoint must be added to the redirect URIs before you upgrade. Note which team owns the identity provider change, since they may need a change ticket. Test a login on the rehearsal instance before touching production.
Rehearse on a non-production instance
Stand up a non-production Argo CD instance with a copy of your exported objects, your SSO client and your custom assets. Run the v2 action calls, a login through each identity path and a sync of representative applications on the new version. Compare the results with production behavior before the change window. Record every failure so the production runbook covers it.
Record CRDs that will gain health checks
List the custom resources in your clusters, especially Gateway API resources, RabbitMQ clusters, CloudNativePG clusters and OpenTelemetry Collectors. Argo CD 3.1 adds built-in health checks for several of these CRDs, so applications that previously showed Healthy may change status. Record the current status of each application that manages them, so you can explain any change after the upgrade.
Upgrade steps with checks and rollback points
This sequence moves an Argo CD 3.0 installation to 3.1 in an order that keeps a known-good state available at every stage, with a check at each step before the next one begins.
Confirm the 3.0 patch level and read the notes
Record the exact Argo CD 3.0 patch version running on the server, the repo-server and the application controller, and confirm the image tags in your manifests match. Then read the official 3.0 to 3.1 upgrade notes in full, and list every item that touches your install: the OIDC authorization code flow, the v1 resource actions API, static assets served from --staticassets, and project API responses. Check that the release pages for the current patch line are reviewed, since the project only patches its three most recent minor versions. Done when you have a written list of which upgrade items apply to your environment and which do not.
Back up cluster state and configuration
Export the Argo CD namespace objects that hold your configuration: Applications, ApplicationSets, AppProjects, repository and cluster Secrets, the argocd-cm, argocd-rbac-cm and argocd-cmd-params-cm ConfigMaps, and any Dex or OIDC settings. Store the export outside the cluster and confirm you can read it back. Argo CD keeps most of its state in Kubernetes objects, so this export is the core of your rollback point. Done when the backup files are stored in a location the upgrade does not touch and you have verified they contain the expected object counts and secret entries.
Update OIDC redirect URIs where PKCE is enabled
If enablePKCEAuthentication is set in your configuration, add the /auth/callback endpoint of your Argo CD URL to the redirect URIs of the OIDC client at your identity provider. In 3.1 the server handles the authorization code flow whether or not PKCE is enabled, so confirm the existing redirect URI remains registered as well. Coordinate this with the team that owns the identity provider, because a missing URI blocks login rather than failing visibly during the upgrade. Done when the identity provider's client configuration lists both URIs and a test login succeeds against a non-production instance.
Rehearse the upgrade on a non-production instance
Restore the backup into a separate Argo CD installation that points at the same Git repositories and a non-production cluster, then apply the 3.1 manifests for your install method. Run the same steps you plan for production, including the OIDC login, a sync of a representative application, and a check of any scripts that call the API. Record every error, warning or changed behavior. Done when the rehearsal completes without unresolved errors and you have a list of any changes needed in production configuration.
Apply the 3.1 manifests for your install method
Apply the 3.1 manifests using the method your team already uses, whether plain manifests, Kustomize, or Helm, and make the change in version control so the desired state is recorded. Apply the update to the production instance during a window your change process approves, and watch the rollout of the API server, repo-server, application controller and Redis until each deployment reports ready. Done when all Argo CD pods run the 3.1 image and the rollout reports no crash loops.
Verify login, sync and health status
Sign in through SSO and confirm your group-to-role mappings still grant the expected access. Then sync one low-risk application, confirm it reaches Synced and Healthy, and check that health status for resources such as CRDs in your environment is correct. Review the application controller logs for errors on reconciliation. Note that 3.1 adds built-in health checks for some CRDs, including Gateway API resources and CloudNativePG clusters, so an application can change health state after the upgrade. Done when a test login, a sync and a health check all match the pre-upgrade baseline.
Check API consumers and static assets
Search your automation, CI pipelines and scripts for calls to the v1 resource actions endpoint, and plan a move to the /api/v1/applications/{name}/resource/actions/v2 endpoint because the older API is deprecated in 3.1. Confirm that project API responses no longer return project-scoped repository and cluster credentials, and update any client that relied on them. If you serve custom files through --staticassets, check that no symlink points outside that directory, since 3.1 returns a 500 error for out-of-bounds symlinks. Done when each consumer has been tested against 3.1 and the static asset directory has been checked for out-of-bounds links.
Define the rollback point and its trigger criteria
Before production cutover, write down the rollback procedure: reapply the 3.0 manifests at the recorded patch version, restore the backed-up Applications, AppProjects and Secrets if state was altered, and verify login and sync again. Agree in advance on the criteria that invoke rollback, such as SSO login failing for administrators, applications failing to reconcile across several clusters, or API consumers failing in a way the team cannot patch quickly. Confirm who has authority to make that call. Done when the rollback steps are documented, rehearsed on the non-production instance, and approved by the change owner.
What makes a 3.0 to 3.1 upgrade take longer
How does the number of SSO clients affect a 3.0 to 3.1 upgrade?
Each OIDC client that uses PKCE needs its redirect URIs updated, so more clients means more change requests and more testing. In Argo CD 3.1 the server handles the authorization code flow whether or not PKCE is enabled, and when enablePKCEAuthentication is set, the /auth/callback endpoint must be added to the OIDC client's redirect URIs. Each identity provider team may own its own change ticket, so coordination adds time even when each edit is small. Ask which clients front Argo CD, who approves changes to them, and whether any run through Dex or a direct OIDC connection, since that determines how many owners you must reach.
Why do scripts that call the v1 resource actions API slow down the upgrade?
Argo CD 3.1 deprecates the v1 resource actions API in favor of /api/v1/applications/{name}/resource/actions/v2, so every pipeline, bot or runbook that calls the old endpoint needs review and retesting. The more automation that depends on the old path, the more owners must confirm their jobs still work. Teams usually find these callers only after a cutover, so a full inventory of CI jobs, cron tasks and internal tools that call the API is the main effort driver. Ask for a list of every client that sends requests to the resource actions path before scheduling the move.
How do custom static assets and symlinks change the upgrade effort?
Argo CD 3.1 returns a 500 error for out-of-bounds symlinks in the --staticassets directory, so an instance with customized UI assets that link outside that directory will fail until the links are fixed. The effort depends on how many asset files exist, how they were added (by hand, by a Helm values file or by a custom image), and whether anyone still knows why each link was created. Teams with no custom assets face little work here. Check the asset directory for symlinks that point outside its tree before the rehearsal, and record which ones carry branding or other customizations.
Does the number of clusters and applications change the work for project-scoped credentials?
Yes. Argo CD 3.1 removes project-scoped repository and cluster credentials from project API responses, as described in GHSA-786q-9hcg-v9ff. Any integration that reads those fields to find which credentials a project uses will stop receiving them, so more clusters, projects and applications mean more places to check. Consumers may include dashboards, inventory tools and deployment scripts. Ask which systems read project API output, and whether any of them depend on credential fields, before scheduling the change.
Does running Argo CD in high availability or self-managed mode add time?
It usually does, because each extra component changes the rollout order and the number of checks. An HA installation runs several replicas across at least three nodes, and the controller can be sharded, so each replica needs confirmation after the change. A self-managed instance, where Argo CD deploys its own manifests from Git, adds steps to update the source of truth and to recover if the new controller fails to start. A single-replica, non-self-managed installation has the fewest moving parts. Confirm the replica count, whether Argo CD manages itself, and where its manifests live.
How much does a non-production rehearsal environment shorten the upgrade?
A rehearsal environment shortens the upgrade by letting you find failures on copies of your real SSO settings, API clients and asset files rather than in production. Without one, the same discovery happens during the change window, which extends the outage risk and the rollback effort. The rehearsal needs a copy of the configuration, representative applications and a current Argo CD version matching production. Ask whether a staging instance exists, whether its SSO client can use the new redirect URI, and how far it mirrors production clusters.
How do change control approvals affect the schedule for a 3.0 to 3.1 upgrade?
Approvals add lead time that is separate from technical work, and they multiply when the upgrade touches identity, API consumers and cluster credentials at once. Each affected area may need its own sign-off from identity, platform, security and application owners, plus a documented rollback plan. Regulated organizations often require evidence that the rehearsal ran and that changes were recorded. Ask your change board which approvals a version upgrade requires, how long they usually take, and whether a standard change category applies.
How the upgrade differs by install method
Teams that apply the upstream install manifests directly, or wrap them in their own Kustomize overlay, control every resource that changes. The main reading is the Argo CD 3.0 to 3.1 upgrade notes, and the change set is whatever the new manifests and your overlay produce. Comparing rendered output before and after the change is the most useful review step.
- Pin the target version: Reference the 3.1 release in your base or overlay so the rendered output is reproducible and reviewable.
- Diff the rendered output: Render the old and new versions and review CRD, RBAC and ConfigMap changes before anything is applied.
- Check your own patches: Overlay patches that touch the server deployment, RBAC or settings may conflict with 3.1 defaults.
- Keep the previous state in Git: A rollback is a commit that restores the prior pinned version, and it only works if that state was kept.
- Confirm CRD downgrade behavior: Check with the release notes whether any CRD change prevents returning to 3.0 cleanly.
Before cutover, confirm with the notes for the exact release you are installing which resources changed, and rehearse the apply and revert on a non-production instance.
Installations managed through the argo-helm chart have two version numbers: the chart version and the Argo CD application version it deploys. The upgrade therefore involves reading the chart changelog and values changes alongside the Argo CD 3.1 notes. Chart-specific details, including how CRDs are installed and upgraded, should be confirmed with the chart documentation before you run the upgrade.
- Map chart to application version: Confirm which chart release deploys Argo CD 3.1 and set the image tag explicitly if your values override it.
- Read both sets of notes: The chart changelog can change defaults that the 3.1 notes do not mention, such as probes, service names or RBAC values.
- Check CRD handling: Confirm whether the chart upgrades CRDs or whether you apply them separately, since Helm does not always update CRDs on upgrade.
- Carry over the OIDC settings: If you use the 3.1 server-side OIDC flow with PKCE, make sure the redirect URI in your values matches the new callback endpoint.
- Review revision history: Helm keeps release revisions, but confirm whether a rollback also restores CRDs and any resources the chart does not manage.
Before upgrading, run helm diff or an equivalent render comparison, and confirm the chart-to-application mapping in the chart documentation.
An Argo CD instance that deploys its own manifests from Git upgrades itself through its own sync process. The version bump, CRD changes and controller restart all pass through the same controller being upgraded, which creates a failure mode that the other methods do not have. The Argo CD 3.0 to 3.1 upgrade notes describe what changes, but the sync options and ordering for your repository layout need to be confirmed for your setup.
- Confirm the sync options: Check whether 3.1 requires any sync option, such as server-side apply, for the resources in your repository.
- Order CRD changes: Make sure CRDs are applied before the resources that depend on them, or the sync may fail partway through.
- Pause automated sync for the upgrade: Stop auto-sync on the self-managing application during the change window so a partial rollout does not reconcile unexpectedly.
- Save last known good manifests: Keep a copy of the working manifests outside the cluster so you can restore them if the new controller does not start.
- Plan for a broken controller: A controller that cannot start cannot reconcile a Git revert, so the recovery path must be a direct apply with
kubectlfrom the saved copy.
Before starting, test the same change on a separate instance and confirm the recovery steps with the people who can run kubectl against the cluster.
Questions teams ask before upgrading Argo CD to 3.1
What does an Argo CD 3.0 to 3.1 upgrade cost?
No price is set by the Argo CD project, which is released under the Apache License 2.0 with no paid edition, so the cost is the work to plan, change, test and verify the upgrade. The main cost components are the people who inventory your OIDC clients, redirect URIs, static asset paths, project API consumers and custom scripts, the staging environment and test time, and the change window at cutover. Costs go up when more Argo CD instances, SSO clients or automations call the affected APIs. Costs go down when the instance is small and the usage is documented. A DeployOpen quote follows from a written scope, so ask for the scope items listed in the answer about what the team must provide.
How long does the upgrade take in our environment?
Duration depends on how many Argo CD instances you run, how many applications and clusters they manage, how many OIDC clients use the PKCE flow, and whether anything in your estate calls the v1 resource actions API. The Argo CD project publishes a minor release cadence of four releases a year and supports only the three most recent minor versions with patches, so the timing of your move relative to that window also matters. Ask your delivery partner for a plan that separates inventory, staging validation, production cutover and post-upgrade checks, and confirm the timeline against your own change calendar.
What must our team provide before the upgrade starts?
Plan for four kinds of access and decisions before work begins:
- Administrative access to the Argo CD namespace, the Kubernetes clusters it manages, and the Git repositories that hold its manifests.
- Administrative access to your identity provider or bundled Dex configuration, so the OIDC client redirect URIs can be checked and updated.
- Named owners for API consumers, including CI jobs and scripts that call the v1 resource actions endpoint.
- Approved change windows for a staging rehearsal and a production cutover, with a rollback decision owner.
Confirm each item in writing, because a missing identity provider change is the most common reason an SSO login breaks after a move.
Can our internal platform team perform this upgrade alone?
Often yes, if the team already runs Argo CD in production and has someone who understands your SSO setup. The upgrade itself is a bounded set of changes, but it touches authentication, API consumers and static asset serving, so the team should review each affected area against its own environment. Teams that lack an owner for the identity provider, or that have many undocumented API clients, usually bring in outside help for the inventory and staging test. Decide early which parts you will own, which parts a partner will carry out under a fixed-scope agreement, and who signs off on the cutover.
Can we roll back if the production cutover fails?
Rollback depends on backups and on how the Argo CD state is stored. Argo CD keeps most of its data in Kubernetes objects and treats Redis as a disposable cache, so a backup of the namespace and the Argo CD resources taken before the change is the core recovery artifact. Record the prior image version, the prior OIDC client configuration and the prior API client behavior, then rehearse the rollback in staging. Confirm with the Argo CD upgrade notes and your own test results whether a downgrade is supported for your specific configuration before you commit to it in the change plan.
Is Argo CD 3.0 still supported after the 3.1 release?
The Argo CD release process says only the three most recent minor versions receive patch releases, so whether 3.0 still receives patches depends on the minor versions published at the time you read the page. Check the Argo CD release process and the GitHub releases page for the current list of supported minor lines before you plan. Staying on an unpatched minor version leaves security fixes out of reach, so the upgrade decision should be tied to that support window and to your own patch policy.
What breaks if we skip the 3.1 changes for OIDC and project API responses?
Engineers should expect SSO sign-in failures if the OIDC client lacks the /auth/callback redirect URI when PKCE is enabled, because the server now handles the authorization code flow in every case. Scripts that call the v1 resource actions endpoint keep working during deprecation but should move to the v2 path. Automation that reads project-scoped repository or cluster credentials from project API responses will stop receiving them, which is intended behavior from the security fix GHSA-786q-9hcg-v9ff. Symlinks in the static assets directory that point outside it now return a 500 error, so check that directory before cutover.
How DeployOpen scopes, delivers and supports the Argo CD 3.0 to 3.1 upgrade
DeployOpen plans and carries out the move from Argo CD 3.0 to 3.1 in infrastructure you control, starting from a written scope that names each affected setting. Work is tested on a non-production instance first, then documented and handed over to your team.
How we scope
- Inventory every Argo CD instance, its version and whether it uses direct OIDC or bundled Dex for sign-in.
- Confirm whether enablePKCEAuthentication is set, so the /auth/callback redirect URI is added where required.
- Identify scripts or dashboards still calling the v1 resource actions API and agree on moving them to the v2 endpoint.
How we build
- Update the OIDC client redirect URIs in the identity provider and test sign-in before changing the Argo CD server.
- Check any custom static assets for symlinks that point outside the --staticassets directory, since these now return a 500 error.
- Review API clients that read project responses, because project-scoped repository and cluster credentials are no longer returned.
How we hand over
- Deliver a written runbook with the exact configuration changes, test results and rollback steps for each affected area.
- Record the pre-upgrade backup, the target version and the verification checks so your team can repeat the process.
- Walk your platform and identity staff through the changed endpoints, callback URIs and health check behavior before cutover.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer if you want DeployOpen to handle future minor releases.
- Ask the quote to state which Argo CD patch line you will track, since only the three most recent minor versions receive patches.
- Confirm with your team who owns Argo CD releases after handover, and agree the review point for the next minor version.

