Argo
Argo is a suite of open-source Kubernetes-native tools for running workflows, managing deployments, handling events, and delivering applications through GitOps. Its components share a declarative, container-first design built on custom resource definitions.
itCloud native tools and technologies | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Argo
Argo is a family of Kubernetes controllers, which is a more useful description than “one platform” and considerably less likely to result in an unnecessary architecture diagram. Each project watches a different kind of request and then records what happened. That shared habit is the thread tying the family together.
The first trick is to identify the question before selecting the tool. Argo Workflows owns a container task graph. It turns a Workflow specification into task Pods and keeps the dependency state. It is not a replacement for a Kubernetes Job that has one independent task and no graph worth remembering.
Argo CD has a different job. It compares the desired resources stored in Git with the live resources in a cluster. A sync applies the declared target, but the useful part is the continuing comparison: a controller can show that live state drifted after the person or pipeline that made the change has gone elsewhere, probably to make coffee.
Argo Rollouts takes over once a new version needs more than a normal rolling update. It can pause a canary, shift traffic, and ask an analysis whether to continue or abort. Argo Events sits at another boundary: an EventSource receives an external signal, an EventBus carries it, and a Sensor decides whether to request a trigger. The system that receives the trigger then owns its execution. Names are doing quite a lot of work here, so keep the handoff visible.
The surprising part is that none of these controllers gives an API write an immediate ending. Creating a custom resource asks for work. Its status, child resources, logs, and conditions show the answer later. That is why a delivery chain such as event, workflow, Git change, sync, and rollout needs explicit inputs, identities, retry behavior, and failure owners at every arrow.
Do not install the whole family because the logo is shared. Start with the one control loop that is missing. Then add least-privilege service accounts, observe status and generated resources, and test failure before connecting another controller. The Intro explains the four responsibilities and their boundaries. Slides compress the decision map. Cheatsheet provides the resources, inspection anchors, and failure signals. Reference points to the official manuals when one controller has become your actual operational concern.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://argoproj.github.io/
Supports
- Argo as open source tools for Kubernetes
- The four-project map of Workflows, CD, Rollouts, and Events
- High-level responsibility of each project
- https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/
Supports
- CRDs as extensions that add resource kinds to the Kubernetes API
- Custom resources as declarative API objects used with custom controllers
- Kubernetes API, authentication, authorization, and tooling behavior for custom resources
- https://kubernetes.io/docs/concepts/architecture/controller/
Supports
- Controllers as control loops that move current state toward desired state
- Asynchronous reconciliation and status-oriented observation
- Separation between submitting desired state and observing completed work
- https://argo-workflows.readthedocs.io/en/latest/
Supports
- Argo Workflows as a container-native workflow engine for parallel jobs on Kubernetes
- Workflow implementation through Kubernetes custom resources
- Machine learning, data processing, infrastructure automation, and CI or CD use cases
- Workflow feature scope including artifacts, templates, retries, scheduling, APIs, and metrics
- https://argo-workflows.readthedocs.io/en/latest/workflow-concepts/
Supports
- Workflow as both executable definition and execution state
- Entrypoint and template structure
- Container, script, resource, and suspend template behavior
- Steps as sequential outer groups with parallel inner tasks
- DAG templates as explicit task dependency graphs
- https://argo-workflows.readthedocs.io/en/latest/walk-through/parameters/
Supports
- Workflow input and output parameter behavior
- Parameters as small values passed into templates and tasks
- https://argo-workflows.readthedocs.io/en/latest/walk-through/artifacts/
Supports
- Input and output artifacts as files or directories
- Artifact passing between tasks through configured artifact repositories
- Separation between parameters, artifacts, volumes, and external storage
- https://argo-workflows.readthedocs.io/en/latest/workflow-rbac/
Supports
- Workflow execution through Kubernetes service accounts
- Separation between workflow controller and workflow permissions
- Least-privilege access for workflow-created pods and resource operations
- https://argo-workflows.readthedocs.io/en/latest/security/
Supports
- Security boundaries for workflow execution, images, secrets, pod privileges, and multi-tenancy
- Risks from untrusted workflow specifications and generated workloads
- Need to combine Argo access controls with Kubernetes security controls
- https://argo-cd.readthedocs.io/en/stable/
Supports
- Argo CD as declarative GitOps continuous delivery for Kubernetes
- Git repositories as desired application state
- Application comparison, OutOfSync status, health, and manual or automated synchronization
- Manifest support for Kustomize, Helm, Jsonnet, plain YAML, and plugins
- Multiple-cluster delivery, drift detection, audit trails, and user interfaces
- https://argo-cd.readthedocs.io/en/stable/operator-manual/architecture/
Supports
- Application controller reconciliation responsibilities
- Repository server manifest generation responsibilities
- API server, repository, and destination-cluster component boundaries
- Argo CD as a controller that compares live and target application state
- https://argo-cd.readthedocs.io/en/stable/user-guide/best_practices/
Supports
- Separation of application configuration repositories from application source where appropriate
- Declarative repository and cluster configuration practices
- Version pinning and manifest-management considerations
- https://argo-cd.readthedocs.io/en/stable/operator-manual/security/
Supports
- Argo CD security architecture, threat model, and hardening controls
- Repository, cluster, credential, project, and user-interface authorization boundaries
- Security responsibilities around manifest generation and managed clusters
- https://argo-rollouts.readthedocs.io/en/stable/
Supports
- Argo Rollouts as a Kubernetes controller and set of CRDs for progressive delivery
- Blue-green, canary, analysis, experimentation, promotion, and rollback features
- Optional ingress-controller, service-mesh, and metrics-provider integrations
- Rollout management of ReplicaSets and progression from stable to new versions
- Limits of native rolling updates that motivate added release controls
- https://argo-rollouts.readthedocs.io/en/stable/concepts/
Supports
- Rollout as a Deployment replacement for advanced release behavior
- Blue-green and canary strategy concepts
- Stable and canary ReplicaSets, services, experiments, and analysis resources
- Traffic weights with and without traffic-routing integration
- https://argo-rollouts.readthedocs.io/en/stable/features/analysis/
Supports
- AnalysisTemplate, ClusterAnalysisTemplate, and AnalysisRun roles
- Background, inline, pre-promotion, and post-promotion analyses
- Metric queries, success conditions, failure limits, and inconclusive or error outcomes
- Analysis-driven continuation, pause, abort, and rollback behavior
- https://argoproj.github.io/argo-events/
Supports
- Argo Events as event-driven workflow automation for Kubernetes
- Event sources including webhooks, object storage, schedules, and messaging systems
- Triggers including Argo Workflows, Kubernetes objects, HTTP requests, and other integrations
- CloudEvents compliance and dependency logic
- https://argoproj.github.io/argo-events/concepts/architecture/
Supports
- EventSource, EventBus, Sensor, and trigger as the main architecture components
- Separation of event receipt, transport, dependency resolution, and action
- https://argoproj.github.io/argo-events/concepts/event_source/
Supports
- EventSource configuration for consuming external events
- Conversion to CloudEvents and publication to an EventBus
- Breadth of supported event-source categories
- https://argoproj.github.io/argo-events/concepts/eventbus/
Supports
- EventBus as the transport layer connecting EventSources and Sensors
- EventSources as publishers and Sensors as subscribers
- Current EventBus implementation choices and lifecycle concerns
- https://argoproj.github.io/argo-events/concepts/sensor/
Supports
- Sensor as a definition of event dependencies and triggers
- Dependency resolution from EventBus events
- Trigger execution after declared dependencies resolve
- https://argoproj.github.io/argo-events/sensors/triggers/argo-workflow/
Supports
- Sensor submission of Argo Workflow resources
- Boundary between event dependency resolution and downstream workflow execution
- https://argoproj.github.io/argo-events/service-accounts/
Supports
- Service-account requirements for EventSource and Sensor operations
- Trigger permissions for creating Kubernetes and Argo resources
- Least-privilege separation for event-driven actions
- https://argoproj.github.io/trainings/
Supports
- Official Argo training and certification route for continued ecosystem study
- https://www.cncf.io/projects/argo/
Supports
- Argo first commit in July 2017
- Argo CNCF incubating acceptance in March 2020 and graduation in December 2022
- https://www.cncf.io/blog/2022/09/30/an-introduction-to-gitops-and-argo/
Supports
- Argo Workflows open sourced in January 2018
- Argo CD and Argo Events followed in 2018
- Argo Rollouts followed in 2019
- https://www.cncf.io/blog/2021/04/07/argo-cd-2-0-released/
Supports
- Argo CD 2.0 announcement in April 2021
- https://github.com/argoproj/argo-workflows/releases/tag/v3.4.0
Supports
- Argo Workflows v3.4 release in January 2023
- https://github.com/argoproj/argo-workflows/releases/tag/v3.5.0
Supports
- Argo Workflows v3.5 release in March 2024
- https://argo-workflows.readthedocs.io/en/latest/walk-through/quick-start/
Supports
- Official quick-start installation and hello-world workflow procedure
- https://fluxcd.io/flux/
Supports
- Flux as a Kubernetes GitOps toolkit with controllers for reconciliation
