Argo CD ApplicationSet Controller

Related tags

Argo argo-cd
Overview

Argo CD ApplicationSet Controller

The ApplicationSet controller is a Kubernetes controller that adds support for a new custom ApplicationSet CustomResourceDefinition (CRD). This controller/CRD enables both automation and greater flexibility when managing Argo CD Applications across a large number of clusters and within monorepos, plus it makes self-service usage possible on multitenant Kubernetes clusters.

The ApplicationSet controller provides the ability:

  • To deploy Argo CD Applications to multiple Kubernetes clusters at once
  • To deploy multiple Argo CD applications from a single monorepo
  • Allows unprivileged cluster users (those without access to the Argo CD namespace) to deploy Argo CD applications without the need to involve cluster administrators in enabling the destination clusters/namespaces
  • Best of all, all these features are controlled by only a single instance of an ApplicationSet custom resource, which means no more juggling of multiple Argo CD Application resources to target those multiple clusters/repos!

Unlike with an Argo CD Application resource, which deploys resources from a single Git repository to a single destination cluster/namespace, ApplicationSet uses templated automation to create, modify, and manage multiple Argo CD applications at once.

If you are loving Argo CD and want to use ApplicationSet's automation and templating to take your usage to the next level, give the ApplicationSet controller a shot!

Example Spec:

# This is an example of a typical ApplicationSet which uses the cluster generator.
# An ApplicationSet is comprised with two stanzas:
#  - spec.generator - producer of a list of values supplied as arguments to an app template
#  - spec.template - an application template, which has been parameterized
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: guestbook
spec:
  generators:
  - clusters: {} # This is a generator, specifically, a cluster generator.
  template: 
    # This is a template Argo CD Application, but with support for parameter substitution.
    metadata:
      name: '{{name}}-guestbook'
    spec:
      project: "default"
      source:
        repoURL: https://github.com/argoproj/argocd-example-apps/
        targetRevision: HEAD
        path: guestbook
      destination:
        server: '{{server}}'
        namespace: guestbook

The Cluster generator generates parameters, which are substituted into {{parameter name}} values within the template: section of the ApplicationSet resource. In this example, the cluster generates name and server parameters (containing the name and API URL for the target cluster), which are then substituted into the template's {{name}} and {{server}} values, respectively.

The parameter generation via multiple sources (cluster, list, git repos), and the use of those values within Argo CD Application templates, is a powerful combination. Learn more about generators and template, the Cluster generator and various other ApplicationSet generators, and more, from the ApplicationSet documentation.

Documentation

Take a look at our introductory blog post, Introducing the ApplicationSet Controller for Argo CD.

Check out the complete documentation for a complete introduction, how to setup and run the ApplicationSet controller, how it interacts with Argo CD, generators, templates, use cases, and more.

Community

The ApplicationSet controller is a community-driven project. You can reach the Argo CD ApplicationSet community and developers via the following channels:

We'd love to have you join us!

Development builds

Development builds can be installed by running the following command:

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj-labs/applicationset/master/manifests/install.yaml

Commits to the master branch will automatically push new container images to the container registry used by this install, and see this link for automatically updated documentation for these builds. See Development builds for more details.

Development

Learn more about how to setup a development environment, build the ApplicationSet controller, and run the unit/E2E tests.

Our end goal is to provide a formal solution to replace the app-of-apps pattern. You can learn more about the founding principles of the ApplicationSet controller from the original design doc.

This project will initially be maintained separately from Argo CD, in order to allow quick iteration of the spec and implementation, without tying it to Argo CD releases. No promises of backwards compatibility are made, at least until merging into Argo CD proper.

Comments
  • Application Set not allowing to use jqPathExpressions

    Application Set not allowing to use jqPathExpressions

    In ApplicationSet, I am not able to use jqPathExpressions under ignoreDifferences. getting validation errors

    Argocd Version used: 2.1.1 Application Set version: 0.3.0

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: xxxsds
      namespace: argocd
    spec:
      generators:
       ...
      template:
        metadata:
          name: xyzzy
        spec:
          ignoreDifferences:
          - group: networking.istio.io
            kind: VirtualService
            jqPathExpressions:
            - .spec.http[*].route[*].weight
    
    error validating data: [ValidationError(ApplicationSet.spec.template.spec.ignoreDifferences[0]): unknown field "jqPathExpressions" in io.argoproj.v1alpha1.ApplicationSet.spec.template.spec.ignoreDifferences, ValidationError(ApplicationSet.spec.template.spec.ignoreDifferences[0]): missing required field "jsonPointers" in io.argoproj.v1alpha1.ApplicationSet.spec.template.spec.ignoreDifferences]
    
    opened by mksha 21
  • Application set not able to delete k8s resources of child application

    Application set not able to delete k8s resources of child application

    Hi, I, currently have a application set (parent), which creates a child argo application (child). When i delete the argo parent app or application set it does not remove the child application k8s resources at all and leave them behind.

    Argo cd details:

    argocd: v2.0.1+33eaf11.dirty BuildDate: 2021-04-21T18:44:13Z GitCommit: 33eaf11e3abd8c761c726e815cbb4b6af7dcb030 GitTreeState: dirty GoVersion: go1.16.3 Compiler: gc Platform: darwin/amd64 argocd-server: v2.0.0+f5119c0 BuildDate: 2021-04-07T06:00:33Z GitCommit: f5119c06686399134b3f296d44445bcdbc778d42 GitTreeState: clean GoVersion: go1.16 Compiler: gc Platform: linux/amd64 Ksonnet Version: v0.13.1 Kustomize Version: v3.9.4 2021-02-09T19:22:10Z Helm Version: v3.5.1+g32c2223 Kubectl Version: v0.20.4 Jsonnet Version: v0.17.0

    bug 
    opened by mksha 18
  • Add Bitbucket cloud support to SCM generator

    Add Bitbucket cloud support to SCM generator

    Would be great to have BitBucket cloud as a provide in SCM generator: https://argocd-applicationset.readthedocs.io/en/stable/Generators-SCM-Provider/#scm-provider-generator

    enhancement 
    opened by jdomag 15
  • Add duck type generator support to ApplicationSets

    Add duck type generator support to ApplicationSets

    • Initial Commit
    • Adds a Duck Type Generator to ApplicationSets that allows the controller to read an external Resource Status.Decisions (array) to determine the list of Argo CD clusters to deploy to.
    • This approach uses the duck type Reference, that allows the user to define what resource will provide placement recommendations for target Argo CD clusters
    • Duck Type Status definition:
    status:
      decisions:
      - clusterName: my-cluster01
      - clusterName: my-cluster02
    
    • Duck Type Reference:
    spec:
      ducktType:
        apiVersion: my-group/v1beta1
        kind: MyKind
        name: my-resource-name
        requeueAfterSeconds: 60         # This is optional, default is 3 min
    
    opened by jnpacker 15
  • Create helm chart

    Create helm chart

    Hi all, I see that Argo provides Helm charts to install ArgoCD or other tools (see https://github.com/argoproj/argo-helm/tree/master/charts). Are you planning to add an helm chart for the ApplicationSet as well?

    I'm happy to raise a PR. Should it be in the same ArgoCD chart as an option or a separate chart?

    enhancement 
    opened by maruina 14
  • feature request - combine generators

    feature request - combine generators

    Hi folks,

    first, thanks for this great project!

    Would it be possible to combine generators?

    in this example combine directory discover with clusters secret

    example:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: cluster-addons
    spec:
      generators:
      - git:
          repoURL: https://github.com/infra-team/cluster-deployments.git
          directories:
          - path: add-ons/*
      - clusters:
         selector:
           matchLabels:
             argocd.argoproj.io/secret-type: cluster
           values:
             project: default 
      template:
        metadata:
          name: '{{name}}-{{path.basename}}'
        spec:
          project: '{{values.project}}'
          source:
            repoURL: https://github.com/infra-team/cluster-deployments.git
            targetRevision: HEAD
            path: '{{path}}'
          destination:
            server: {{server}}
            namespace: '{{path.basename}}'
    

    When I try, run into

    error converting YAML to JSON: yaml: invalid map key: map[interface {}]interface {}{"server":interface {}(nil)}
    
    enhancement 
    opened by 1337andre 13
  • fix: return revision from getGitGeneratorInfo

    fix: return revision from getGitGeneratorInfo

    It seems that the webhook endpoint was not working completely as expected when tracking a repository branch (other than the default branch).

    It turns out that the revision that is being used to compare against the targetRevision is always empty. So the test on https://github.com/argoproj/applicationset/blob/master/pkg/utils/webhook.go#L246 would always return false.

    The revision field is already being evaluated on https://github.com/argoproj/applicationset/blob/master/pkg/utils/webhook.go#L146, but for some reason it was never included in the response.

    After this change, we verified this on our own installation and now the webhook processing does recognize the correct branches on push events from GitHub.

    opened by reiniertimmer 12
  • How to get an ApplicationSet to spawn Applications in Argo CD?

    How to get an ApplicationSet to spawn Applications in Argo CD?

    I've been installing the ApplicationSet together with Argo CD 2.0.0 and 2.0.1 without any success in spawning applications from a any generators. Maybe I am missing something trivial, but how do you get the ApplicationSet into Argo CD?

    I have tried adding an Application in Argo CD with a path to a folder in the git repo that contains a spec for an ApplicationSet, or several. I can see the argocd-applicationset-controller running as a replica set and stateful set.

    This is what it looks like in Argo CD... image

    question 
    opened by WillooWisp 12
  • chore: fixed failing builds, updated docker login

    chore: fixed failing builds, updated docker login

    Signed-off-by: Justin Marquis [email protected]

    Fixed the image build failing for push events. Added GOLANG_VERSION as an environment variable. In PR#499 changes were made in the Makefile, they are still needed for github/workflows/ci-build.yaml left them as is.

    opened by 34fathombelow 9
  • Matrix generator where a generator can reference items of another one

    Matrix generator where a generator can reference items of another one

    I'm wondering if this would be possible that a generator use another's generator items.

    For instance, imagine the following manifests structure on a GitOps repository:

    - dev
        - instanceA
        - instanceB
    - prod
        - instanceA
        - instanceB
        - instanceC
        - instanceD
    

    Each instance being defined as a single Argo application. Thus 6 instances, 6 Argo applications.

    Right now, I use a List generator with 6 items corresponding to the 6 variants.

    I would like to be able to define a Matrix generator that would combine:

    • a list generator for the 1st level (dev/prod)
    • a git directory generator for the 2nd level but here the path should be able to reuse the list generator attribute

    Something like (draft):

    generators:
      - matrix: 
        - list:
            elements:
              - platform: dev
                cluster: dev
              - platform: prod
                cluster: prod
        - git:
           directories:
             - path: {{platform}}/* # <-- here reuse {{platform}} of first generator
    

    That's not possible for now, right? Or did I miss something?

    opened by gaeljw 9
  • Support log-level for controller logs

    Support log-level for controller logs

    @jgwest EDIT: Enhancement Request: Add support for configurable log levels via parameter, eg the ability to set additional log levels beyond just the --debug parameter support we have now. For example, as requested, ability to set the log level to only show error or warn.

    Original Text from @dorroddorrod Hi, Is there any way to control the log level for the application-set controller ?

    enhancement help wanted good first issue 
    opened by dorroddorrod 9
  • using helm and git repos inside ApplicationSet

    using helm and git repos inside ApplicationSet

    Hello. Is there a possibility to configure an ApplicationSet to create Applications with helm or git sources?

    Example:

        spec:
          source:
            repoURL: "{{source.repoURL}}"
            chart:  "{{source.chart}}" # how will this key be dynamic?
            path: "{{source.path}}" # how will this key be dynamic?
            targetRevision: '{{source.targetRevision}}'
            helm:
              values:
                "{{source.helm.values}}"
    

    And parameters should look something like this (will be passed by generators):

    - appName: app1
      source:
        repoURL: my-helm-repo
        targetRevision: my-chart-version
        chart: my-chart
        helm:
          values: {}
    - appName: app2
      source:
        repoURL: my-git-repo
        targetRevision: my-git-branch
        path: my-chart
        helm:
          values: {}
    

    My use case is that I am storing helm charts inside git repos and for development purposes I point the Application to the git repo (with repoURL being a git repo and targetRevision being a git branch). After development is finished, the helm chart is published to a helm repo and I am referencing that in the Application. I want to achieve the same using ApplicationSets.

    I did some research and the only thing that might help is this feature #11213 (with variant #11183), so I can use something like this in the ApplicationSet definition

        spec:
          source: "{{source}}"
    

    Is there any way of achieving this functionality?

    opened by adabuleanu 0
  • FATA[0000] rpc error: code = Unimplemented desc = unknown service applicationset.ApplicationSetService

    FATA[0000] rpc error: code = Unimplemented desc = unknown service applicationset.ApplicationSetService

    i am trying to use the latest argocd cli with appset to apply this applicationset but getting error when applying by running this command argocd appset create file.yaml

    FATA[0000] rpc error: code = Unimplemented desc = unknown service applicationset.ApplicationSetService
    

    here is the sample application set.

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: deploy-teleport-configmap
    spec:
      generators:
      - list:
          elements:
          - prefix: teleport-configmap-us-west-2
            url: eks-cluster-1
            region: us-west-2
            environment: qa
          - prefix: teleport-configmap-eu-central-1
            url: eks-cluster-2
            region: eu-central-1
            environment: qa
          - prefix: teleport-configmap-ca-central-1
            url: eks-cluster-3
            region: ca-central-1
            environment: qa
      template:
        metadata:
          name: '{{prefix}}'
        spec:
          project: teleport
          source:
            repoURL: url-repo
            targetRevision: initial-testing
            path: deploy/argocd/config/teleport/{{region}}
          destination:
            server: '{{url}}'
            namespace: teleport
          syncPolicy:
            automated:
              prune: true
              selfHeal: true
            syncOptions:
              - CreateNamespace=true
    
    opened by renperez-cpi 2
  • requeueAfterSeconds was incorrectly placed

    requeueAfterSeconds was incorrectly placed

    When I run the example, I get an error because requeueAfterSeconds is misplaced. When I moved like the PR then it worked, so I am assuming is not in the correct place in docs.

    opened by lordofthejars 0
  • Webhooks: add support for Bitbucket

    Webhooks: add support for Bitbucket

    There's already support for Bitbucket (Server) Pull Request generators but the webhooks sent by Bitbucket are not processed. They just end up with an response saying "Webhook processing failed: event not defined to be parsed".

    In order to complete the support for Bitbucket as SCM provider, supporting their webhooks would be highly appreciated.

    opened by thomascube 1
  • Cluster Resource Generator

    Cluster Resource Generator

    Add the ability to generate Applications from downstream cluster resources, eg:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: monitoring-addon
      namespace: argocd
    spec:
      generators:
        - clusterResource:
            apiVersion: tenant.io/v1
            kind: Tenant
            # namespace: <optional>
            labelSelector:
              matchLabels:
                tenant.io/sync: 'true'
    
    apiVersion: tenant.io/v1
    kind: Tenant
    metadata:
      name: tenant1
      labels:
        tenant.io/sync: 'true'
    spec: {}
    
    apiVersion: tenant.io/v1
    kind: Tenant
    metadata:
      name: tenant2
      labels:
        tenant.io/sync: 'true'
    spec: {}
    

    ArgoCD should generate two applications from these resources.

    opened by aslafy-z 0
Releases(v0.4.1)
  • v0.4.1(Mar 10, 2022)

  • v0.4.0(Mar 8, 2022)

    I am happy to announce the latest release of the Argo CD ApplicationSet controller, v0.4.0. With this release, and alongside Argo CD v2.3.0, we now fully integrate with the default Argo CD install, which means you now only need to install Argo CD to get the full benefits of ApplicationSets.

    Contributors

    Thanks to all the folks who have contributed to the ApplicationSet controller since our last release.

    • Michael Crenshaw (@crenshaw-dev)
    • Ricardo Rosales (@missingcharacter)
    • Ishita Sequeira (@ishitasequeira)
    • stempher (@stempher)
    • Jonathan West (@jgwest)
    • Hüseyin Celal Öner (@hcelaloner)
    • William Tam (@wtam2018)
    • Marco Kilchhofer (@mkilchhofer)
    • Chetan Banavikalmutt (@chetan-rns)
    • Ahmed AbouZaid (@aabouzaid)
    • Matthias Lisin (@ml-)

    Want to join us for our next release? Check out the project repository (https://github.com/argoproj/applicationset) or visit us on #argo-cd-appset on Slack (https://argoproj.github.io/community/join-slack/).

    New in this release

    ApplicationSet controller is now integrated with Argo CD install

    The ApplicationSet controller is now installed by default with the latest release of Argo CD. This means that users of Argo CD now get all the benefits of ApplicationSets, without the requirement of a standalone install.

    Contributed by @ishitasequeira and @jgwest.

    Git generator: Add support for extraction of components of paths

    The Git generator now supports the extraction of individual components of the path, with the new path[n] parameter:

    • {{path[n]}}: The path to the matching configuration file within the Git repository, split into array elements (n - array index).
    • For example, for a path of /clusters/clusterA, the individual components can be extracted like so: path[0]: clusters, path[1]: clusterA

    Contributed by @stempher.

    Git generator: Sanitize basename param by replacing unsupported characters

    When using the Git generator, with a basename name param that contains an unsupported character, you may now use the {{path.basenameNormalized}} parameter to normalize these resources. This prevents rendering invalid Kubernetes resources with names like my_cluster-app1, and instead would convert them to my-cluster-app1.

    Contributed by @missingcharacter.

    Make webhook address configurable

    When using a webhook, the address of the webhook can now be configured using the --webhook-addr parameter on the argocd-applicationset controller.

    Example:

    ./dist/argocd-applicationset --webhook-addr=":9999" --logformat=json
    

    Contributed by @chetan-rns.

    Fixes / Chores

    • ApplicationSet CRD size reduction, by removing validation (CRD defn) of nested merge/matrix generator (#463, contributed by @jgwest)
    • Reap zombie processes in argocd-applicationset-controller pod using tini (#453, contributed by @hcelaloner)
    • Log all validation errors (#439, contributed by @crenshaw-dev)
    • Set applicationset-controller containerPort name (#444, contributed by @aabouzaid)
    • Append missing s to matchExpression (#449, contributed by @ml-)
    • Set controller logger if we don't use JSON format (#451, contributed by @mkilchhofer)
    • Remove hardcoded namespace from manifests (#474, contributed by @ishitasequeira)
    • Fix docs typo (#493 and #481, contributed by @crenshaw-dev)

    Test/infrastructure improvements:

    • E2E tests should use application-controller serviceaccount, rather than applicationset-controller serviceaccount (#434, contributed by @jgwest)
    • Add GitHub action to run E2E tests against nightly Argo CD, w/ ApplicationSet master branch (#470, contributed by @jgwest)
    Source code(tar.gz)
    Source code(zip)
  • v0.3.0(Dec 16, 2021)

    I am happy to announce the latest release of the Argo CD ApplicationSet controller, v0.3.0. Many new features were contributed as part of this release, including two new generators, improved error reporting and handling, support for webhook-based refresh trigger, plus doc updates, usability improvements, stability fixes, and more.

    You can learn more about this release from the ApplicationSet documentation, or check out the project repository and learn how you can contribute.

    Contributors

    Thanks to all the folks who have contributed to the ApplicationSet controller since our last release!

    • Shunya Murata (@shmurata)
    • Michael Crenshaw (@crenshaw-dev)
    • Jonathan West (@jgwest)
    • Ishita Sequeira (@ishitasequeira)
    • Chetan Banavikalmutt (@chetan-rns)
    • Alexander Matyushentsev (@alexmt)
    • Shiv Jha-Mathur (@shivjm)
    • Subhash Chandra (@TMaYaD)
    • William Tam (@wtam2018)
    • Benoit Gaillard (@benoitg31)
    • Michal Barecki (@mbarecki)
    • Guillaume Dupin (@yogeek)
    • Krzysztof Dąbrowski (@krzysdabro)
    • Olve S. Hansen (@olvesh)
    • Dewan Ishtiaque Ahmed (@dewan-ahmed)
    • Diego Pomares (@DiegoPomares)

    Want to join us for our next release? Check out the project repository (https://github.com/argoproj-labs/applicationset) or visit us on #argo-cd-appset on Slack.

    New in this release

    New generator: Pull Request generator

    With ApplicationSet v0.3.0, a new Pull Request generator has been contributed which uses the API of an SCMaaS provider (e.g. GitHub) to automatically discover open pull requests within an repository. This fits well with users that wish to construct a test environment based on an open pull request.

    In this example, we will create an Argo CD Application resource for each open pull request:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: myapps
    spec:
      generators:
      - pullRequest:
          github:
            # The GitHub organization or user.
            owner: myorg
            # The Github repository
            repo: myrepository
            # For GitHub Enterprise (optional)
            api: https://git.example.com/
            # Reference to a Secret containing an access token. (optional)
            tokenRef:
              secretName: github-token
              key: token
            # Labels is used to filter the PRs that you want to target. (optional)
            labels:
            - preview
      template:
      # (template the Application using PR generator params)...
    

    To learn more, check out the Pull Request generator documentation for details. Contributed by @shmurata.

    New generator: Merge generator

    Also new in this release is the Merge generator, which is useful when you want to selectively override the parameters generated by one generator, with those generated by another.

    In this example, we first gather the list of clusters from Argo CD, then we 'patch' only those clusters with label use-kakfa: false, and finally we enable redis on a specfic cluster:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: cluster-git
    spec:
      generators:
        # merge 'parent' generator
        - merge:
            mergeKeys:
              - server
            generators:
              # Generate parameters for all Argo CD clusters
              - clusters:
                  values:
                    kafka: 'true'
                    redis: 'false'
              # For clusters with a specific label, enable Kafka.
              - clusters:
                  selector:
                    matchLabels:
                      use-kafka: 'false'
                  values:
                    kafka: 'false'
              # For a specific cluster, enable Redis.
              - list:
                  elements: 
                    - server: https://2.4.6.8
                      values.redis: 'true'
    

    See the Merge generator documentation for a full example, and for details on generator behaviour. Contributed by @crenshaw-dev.

    Report error conditions/status for ApplicationSet CR

    When the user-provided generator/template produces invalid Argo CD Applications, the ApplicationSet resource's status field will now report errors (or the lack thereof). Here is an example of the new status conditions:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: myapps
    spec:
      generators: # (...)
      template: # (...)
    status:
      conditions:
      - lastTransitionTime: "2021-11-23T05:47:08Z"
        type: ErrorOccurred
        status: "False"
        reason: ApplicationSetUpToDate
        message: Successfully generated parameters for all Applications
      - lastTransitionTime: "2021-11-23T05:47:08Z"
        type: ParametersGenerated
        message: Successfully generated parameters for all Applications
        reason: ParametersGenerated
        status: "True"
      - lastTransitionTime: "2021-11-23T05:47:08Z"
        type: ResourcesUpToDate
        status: "True"
        reason: ApplicationSetUpToDate
        message: ApplicationSet up to date
    

    On parameter generation failure or templating failure, those errors will be reported under the appropriate conditions. Contributed by @ishitasequeira.

    Git Generator: Refresh ApplicationSet resource with Git generator using webhook

    This feature adds support for refreshing ApplicationSets via a GitHub webhook trigger. It exposes a service which listens for incoming webhook payloads, and once received triggers the ApplicationSet controller to regenerate resources. In contrast, with the previous release, the ApplicationSet controller only supported polling the Git repository used by the Git generator every 3 mins (but this is at least customizable).

    See the webhook documentation for details. Contributed by @chetan-rns.

    This contribution also adds general support for webhooks, which is used by the Pull Request generator webhook code, below.

    Gracefully handle application validation errors

    This feature changes how the ApplicationSet controller handles ApplicationSets that generate invalid Applications. Previously, if at least one Application in the ApplicationSet was invalid, the controller would refuse to proceed further and would skip all Application processing (i.e. it would 'fail fast'). Now, the controller will process valid Applications, and only skip invalid Applications (logging information about them to the console).

    Contributed by @alexmt.

    Pull Request generator: Support for webhooks

    When using a Pull Request generator, the ApplicationSet controller polls every requeueAfterSeconds interval (defaulting to every 30 minutes) to detect changes. To eliminate this delay from polling, the ApplicationSet webhook server can be configured to receive webhook events, which will refresh the parameters generated by the Pull Request generator, and thus the corresponding Application resources.

    More information on configuring webhooks with the Pull Request generator is available from the Pull Request generator documentation. Contributed by @shmurata.

    Improve Git files generator performance (#355)

    The Git files generator was consuming too much time (and driving up Git requests) due to inadvertently executing 'git fetch/git checkout' for each discovered file within the repository. With ApplicationSet v0.3.0, that has improved such that we will now issue a Git checkout/fetch repo once per refresh. Contributed by @alexmt.

    Support -logformat=json as parameter to applicationset-controller

    This feature adds a new --logformat=json parameter to the applicationset-controller, which switches the logging output of the ApplicationSet controller to JSON. Contributed by @shivjm.

    SCM Generator: Provide SHA for latest commit on a branch in variables (#307)

    This feature adds SHA to the list of parameters exposed by the SCM Generator, with the SHA parameter representing the latest commit. Contributed by @TMaYaD.

    Fixes, test fixes, infrastructure improvements, and documentation updates

    Fixes

    • Fix: new variable for the normalized version of name field (#390, contributed by @chetan-rns)
    • Fixes GitLab RepoHasPath error handling (#423, contributed by @benoitg31)

    Test/infrastructure improvements:

    • Investigate Argo CD deletion failure messages when running ApplicationSet E2E tests in on-cluster configuration (#392, contributed by @jgwest)
    • Update master branch VERSION file and metadata, and pull up release changes from 0.2.0 (#343, contributed by @jgwest)
    • Skip E2E tests that require GitHub token, if not specified (#380, contributed by @jgwest)
    • API rate limit error in image publish action (#368, contributed by @jgwest)
    • Disable SCM Provider Unit tests on PRs (#337, contributed by @jgwest)
    • Fix lint-docs (#411, contributed by @crenshaw-dev)
    • Fix indentation in example (#360, contributed by @DiegoPomares)
    • Adding required 'version' field for Helm Charts (#332, contributed by @dewan-ahmed)
    • Adopt latest Argo CD dependencies, in preparation for next release (#410, contributed by @jgwest)

    Doc updates

    • Update release process docs and include release checklist in docs (#365, contributed by @jgwest)
    • Fix includeSubgroups reference name (#357, contributed by @yogeek)
    • Add missing brace (#349, contributed by @krzysdabro)
    • Fix Git Generator Files path example in docs (#408, contributed by @mbarecki)
    • Corrected wrong info about path and path.basename (#412, contributed by @olvesh)

    Upgrade Notes

    When moving from ApplicationSet v0.1.0/v0.2.0, to v0.3.0, there are two behaviour changes to be aware of.

    Cluster generator: {{name}} parameter value will no longer be normalized, but existing normalization behaviour is preserved in a new {{nameNormalized}} parameter

    The Cluster generator {{name}} parameter has now reverted to its original behaviour: the cluster name within Argo CD will no longer be normalized. The {{name}} parameter generated by the Cluster generator within the ApplicationSet will now be passed unmodified to the ApplicationSet template.

    A new parameter, {{nameNormalized}} has been introduced which preserves the 0.2.0 behaviour. This allows you to choose which behaviour you wish to use in your ApplicationSet, based on the context in which it is used: either using the parameter as defined, or in a normalized form (which allows it to be used in the name field of an Application resource.)

    If your Argo CD cluster names are already valid, no change is required. Otherwise, to preserve the v0.2.0 behaviour of your ApplicationSet, replace {{name}} with {{nameNormalized}} within your ApplicationSet template.

    More information about this change is available from the issue.

    If an ApplicationSet contains an invalid generated Application, the valid generated Applications will still be processed

    The responsibility of the ApplicationSet controller is to convert an ApplicationSet resource into one or more Application resources. However, with the previous releases, if at least one of the generated Application resources was invalid (e.g. it failed the internal validation logic), none of the generated Applications would be processed (they would not be neither created nor modified).

    With the latest ApplicationSet release, if a generator generates invalid Applications, those invalid generated Applications will still be skipped, but the valid generated Applications will now be processed (created/modified).

    Thus no ApplicationSet resource changes are required by this new behaviour, but it is worth keeping in mind that your ApplicationSets which were previously blocked by a failing Application may no longer be blocked. This change might cause valid Applications to now be created/modified, whereas previously they were prevented from being processed.

    More information about this change is available from the issue.

    Installation

    The ApplicationSet controller must be installed into the same namespace as the Argo CD it is targeting:

    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj-labs/applicationset/v0.3.0/manifests/install.yaml
    

    Once installed, the ApplicationSet controller requires no additional setup. You can learn more about ApplicationSet controller installation from the Getting Started page.

    Source code(tar.gz)
    Source code(zip)
  • v0.2.0(Aug 9, 2021)

    v0.2.0

    I am happy to announce the second release of the Argo CD ApplicationSet controller, v0.2.0. Many new features were contributed as part of this release, including support for combining generator parameters, support for building Argo CD Applications based on GitHub/GitLab organizations, and support for using custom resources to select clusters, plus oft requested improvements to existing generators, and of course doc updates, usability improvements, stability fixes, and more.

    You can learn more about this from the ApplicationSet documentation or check out the source and learn how you can contribute.

    Contributors

    Many many thanks to all the folks who have contributed to the ApplicationSet controller over the past few months. These many contributions, both big and small, general and specific, help to bring a more featureful and polished experience to Argo CD users. We could not do this without all of you!

    • Omer Kahani (@OmerKahani)
    • Joshua Packer (@jnpacker)
    • Jonathan West (@jgwest)
    • Noah Kantrowitz (@coderanger)
    • Lior Lieberman (@LiorLieberman)
    • Michael Matur (@mmatur)
    • TJ Miller (@teejaded)
    • John Thompson (@empath-nirvana)
    • Ishita Sequeira (@ishitasequeira)
    • Chetan Banavikalmutt (@chetan-rns)
    • William Tam (@wtam2018)
    • John Watson (@dctrwatson)
    • Tencho Tenev (@tenevdev)
    • Ryan Umstead (@rumstead)
    • Stephan Auerhahn(@palp)
    • Christian Hernandez (@christianh814)
    • Mohit Kumar Sharma (@mksha)
    • Vivien Fricadel (@vivienfricadelamadeus)
    • Gareth Western (@gdubya)
    • William Jeffries (@williamcodes)
    • Mehran Poursadeghi (@mehran-prs)

    Want to join us for our next release? Check out the project repository (https://github.com/argoproj-labs/applicationset) or visit us on #argo-cd-appset on Slack (https://argoproj.github.io/community/join-slack/).

    New in this Release

    Matrix generator

    The Matrix generator is a new generator that combines the parameters generated by two child generators, iterating through every combination of each generator's set:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: cluster-git
    spec:
      generators:
        - matrix: # 'Parent' Matrix Generator
            generators:
              - git: # 'Child' generator A
                  repoURL: https://github.com/argoproj-labs/applicationset.git
                  revision: HEAD
                  directories:
                    - path: examples/matrix/cluster-addons/*
              - clusters: # 'Child' generator B
                  selector:
                    matchLabels:
                      argocd.argoproj.io/secret-type: cluster
      template:
      # (...)
    

    The parameters generated by a Git generator (looking for directories within a Git Repository), and by a Cluster generator (looking for Argo CD-managed clusters), are combined: this will generate Argo CD Applications that target each of the Git directories (containing Kubernetes manifests), for each cluster managed by Argo CD.

    See the Matrix generator documentation for an in-depth example of how generator parameters are combined. Contributed by @OmerKahani.

    SCM Provider generator

    The SCM Provider generator is a new generator that utilizes the API of GitHub/GitLab to automatically discover repositories within an organization, allowing the repository values to be used for targeting generated Argo CD Applications. This fits well with GitOps layout patterns that split microservices across many repositories, rather than those patterns that stick to a single repository (which can be handled by other ApplicationSet generators).

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: myapps
    spec:
      generators:
      - scmProvider:
          github:
            organization: myorg         # The GitHub organization to scan.
            tokenRef: { } # Reference to a Secret containing an access token. (optional)
      template:
      # ...
    

    The ApplicationSet controller will then scan the provided GitHub/GitLab organization and produce template parameters for each discovered repository/branch, which may be used to generate Argo CD Applications for each of these repositories.

    See the SCM Provider generator documentation for more information. Initial implementation and GitHub support contributed by @coderanger, and GitLab support contributed by @empath-nirvana.

    Cluster Decision Resource generator

    The Cluster Decision Resource generator is a new generator that generates a list of Argo CD clusters based on the contents of an external custom resource (CR), with that custom resource managed by an external controller. With the Cluster Decision Resource generator, you may 'outsource' the logic (of which clusters to target) to third party controllers/CRs, such as the Open Cluster Management's Placements.

    This is handled seamlessly using duck-typing, which does not require knowledge of the full shape of the referenced Kubernetes resource. The following is an example of a cluster-decision-resource-based ApplicationSet generator:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
     name: guestbook
    spec:
     generators:
     - clusterDecisionResource:
        # ConfigMap with GVK information for the duck type resource
        configMapRef: my-configmap      
        name: quak  # Choose either "name" of the resource or "labelSelector"
    

    Which might reference an external resource named quak, managed by an external controller, containing a list of clusters:

    apiVersion: mallard.io/v1beta1
    kind: Duck
    metadata:
      name: quak
    spec: {}
    status:
      decisions:   # Duck-typing ignores all other aspects of the resource except the "decisions" list
      - clusterName: cluster-01
      - clusterName: cluster-02
    

    See the Cluster Decision Resource generator documentation for more information. Cluster Decision Resource generator and labelSelector support contributed by @jnpacker.

    Preserve Application child resources on deletion of parent ApplicationSet

    By default, Applications created and managed by the ApplicationSet controller include the Argo CD resource deletion finalizer. This means that when an ApplicationSet is deleted, its child Applications will be deleted, as well as the cluster resources of those child Applications. This is the same behaviour as a cascade delete within Argo CD.

    However, this behaviour is not always desirable: one may want to preserve the Application child resources on deletion of the parent Application. To enable this, using the .spec.syncPolicy.preserveResourcesOnDeletion value in the parent ApplicationSet:

    kind: ApplicationSet
    spec:
      generators:
        - clusters: {}
      template:
        # (...)
      syncPolicy:
        # Don't delete Application's child resources, on parent deletion:
        preserveResourcesOnDeletion: true
    

    See the Application Deletion Behaviour documentation for more information. Contributed by @mmatur.

    Add YAML configuration file support to Git File generator

    In the previous ApplicationSet release, only JSON-formatted configuration files were supported by the Git File generator. Now, both JSON and YAML files are supported, and may be used interchangeably. Contributed by @teejaded.

    Allow any key/value pair in List generator

    The List generator previously only supported a fixed list of cluster name/URL values, with an optional values field for user-defined values. You can now specify any key/value pair:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    spec:
     generators:
     - list:
         elements:
         # current form, still supported:
         - cluster: engineering-dev
           url: https://kubernetes.default.svc
           values:
             additional: value
         # new form, does not require cluster/URL keys:
         - staging: true
           gitRepo: https://kubernetes.default.svc   
     template:
       # (...)
    

    This new form is fully backwards compatible with existing v0.1.0-originated ApplicationSets, and no migration steps are needed. See the List generator documentation for more information. Contributed by @ishitasequeira.

    Added additional path params to Git File generator

    The Git File generator now produces {{ path }} and {{ path.basename }} parameters, containing the path of the configuration file, similar to the same parameters already produced by the Git Directory generator. Contributed by @ishitasequeira.

    Add exclude path support to Git directories

    The Git Directory generator scans directories within a Git repository, looking for directories that match specific criteria. However, with the previous ApplicationSet release, there was no way to exclude folders from the scan.

    The ability to exclude individual paths from being scanned is now supported:

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: cluster-addons
    spec:
      generators:
      - git:
          repoURL: https://github.com/argoproj-labs/applicationset.git
          revision: HEAD
          directories:
          # Include this first path 
          - path: examples/git-generator-directory/excludes/cluster-addons/* 
          # But, exclude this second path:
          - path: examples/git-generator-directory/excludes/cluster-addons/exclude-helm-guestbook
            exclude: true
    

    Contributed by @LiorLieberman.

    Quality of Life Improvements

    • Git Directory generator should ignore all folders starting with '.' (#201, contributed by @LiorLieberman)
    • Add support for custom 'finalizers' in Application templates (#289, contributed by @tenevdev)
    • Enable the ability to set log level on ApplicationSet controller startup (#249, contributed by @rumstead)
    • Add 'appset/appsets' shortnames to the ApplicationSet CRD (#184, contributed by @christianh814)
    • Log appset version during controller startup log (#241, contributed by @chetan-rns)

    Fixes, infrastructure, and docs

    Fixes:

    • Race condition on cluster creation/deletion causes unexpected behaviour (#198, contributed by @jgwest)
    • Sanitize cluster name param by replacing unsupported character (#237, contributed by @chetan-rns)
    • Remove the unused SkipPrune from ApplicationSetSyncPolicy (#268, contributed by @ishitasequeira)
    • ApplicationSets that initially fail validation might not be re-reconciled (#296, contributed by @jgwest)
    • Remove unnecessary RBAC permissions 'delete events' and 'update events' that are not available at namespace level (#278, contributed by @vivienfricadelamadeus)
    • Issue 170 is not solved when using server, only when using name for destination (#282, contributed by @jgwest)
    • Check path exists passed in application spec (#253, contributed by @mksha)
    • Handle conversion to string in git generator (#235, contributed by @chetan-rns)
    • Add git-lfs to resolve error using files generator (#215, contributed by @palp)
    • Preserve ArgoCD Notification state (#193, contributed by @dctrwatson)
    • Matrix generator's getParams should check error return to avoid panic (#326, contributed by @jgwest )
    • Add missing generators to supported Matrix child generators (#328, contributed by @jgwest)

    Test/infrastructure improvements:

    • Use a fixed version of Kustomize in the Makefile to generate manifests (#207, contributed by @jgwest)
    • Intermittent E2E test failure on TestSimpleGitFilesPreserveResourcesOnDeletion (#229, contributed by @jgwest)
    • Write additional tests for repo_service.go (#226, contributed by @jgwest)
    • Add more cluster e2e tests (#148, contributed by @OmerKahani)
    • Rebase go.mod to latest Argo CD v2.0, adopt new APIs as needed, and retest (#281, contributed by @jgwest)
    • TestGetFileContent test is failing when running go test, on Mac (#246, contributed by @jgwest)
    • Update build scripts to target 'argoproj/applicationset' on quay.io (#242, contributed by @jgwest)
    • Automatically build and push a container image to argoproj/argocd-applicationset:latest on each master commit (#256, contributed by @jgwest)
    • Split generators into separate doc pages, plus general doc updates (#267, contributed by @jgwest)
    • Use image-push target to build and push an image (#264, contributed by @chetan-rns)
    • Update Argo CD dependency to latest, and update changed APIs (#310, contributed by @jgwest)
    • Increment version for next release (#188, contributed by @jgwest)
    • Use a fixed version of controller-gen in the Makefile to generate manifests (#233 contributed by @jgwest)
    • Update Dockerfile to latest Argo CD base and better cleanup apt dependencies #302, contributed by @jgwest)
    • Add GITHUB_TOKEN and GITLAB_TOKEN to actions and test secrets (#320)

    Doc updates:

    • Document the policy parameter of the controller (#297, contributed by @jgwest)
    • Update documentation to mention development builds (#263, contributed by @jgwest)
    • Add a note regarding use of set-based requirements (#228, contributed by @gdubya)
    • Refresh README.md based on new documentation (#191, contributed by @jgwest )
    • Fix minor grammar mistake in README (#217, contributed by @williamcodes)
    • Correct list generator syntax (#204, contributed by @gdubya)
    • Update Generators-Git.md
    • Tweak List and Git generator docs (#333, contributed by @jgwest)
    • Generator updates, upgrade instructions, and misc updates (#313, contributed by @jgwest)

    Installation

    The ApplicationSet controller must be installed into the same namespace as the Argo CD it is targeting:

    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj-labs/applicationset/v0.2.0/manifests/install.yaml
    

    Once installed, the ApplicationSet controller requires no additional setup. You can learn more about ApplicationSet controller installation from the Getting Started page.

    Source code(tar.gz)
    Source code(zip)
  • v0.1.0(Apr 7, 2021)

    v0.1.0

    I am excited to announce the first release of the Argo CD ApplicationSet controller, v0.1.0, releasing now alongside Argo CD v2.0!

    The ApplicationSet controller provides the ability:

    • To deploy Argo CD Applications to multiple Kubernetes clusters at once
    • To deploy multiple Argo CD applications from a single monorepo
    • Allows unprivileged cluster users (those without access to the Argo CD namespace) to deploy Argo CD applications without the need to involve cluster administrators in enabling the destination clusters/namespaces
    • Best of all, all these features are controlled by only a single ApplicationSet Kubernetes custom resource, which means no more juggling of multiple Argo CD Application resources to target those multiple clusters/repos!

    Unlike with an Argo CD Application resource, which deploys resources from a single Git repository to a single destination cluster/namespace, ApplicationSet uses templated automation to create, modify, and manage multiple Argo CD applications at once.

    You can learn more about this from the ApplicationSet documentation or check out the source and learn how you can contribute.

    Since this is our first release, we would ❤️ if you would give ApplicationSets a shot, and let us know what cool problems you are solving with it, or what pain points you hit. Got feature requests, bug reports, or want to contribute code? Let us know on our project repository, or join us on #argo-cd-appset on Slack.

    Contributors

    A great deal of work has gone into bringing this project to life, from many different contributors, all the way from its inception in early 2020 until today. It is terrific to be able to bring all that work together as ApplicationSet's first release, and make it available to a wider audience… we welcome you to try it out, and let us know what you think! A big thanks to all ApplicationSet controller contributors for their hard work over the last year, whether it be contributing code, writing design documentation, performing code reviews, writing user documentation, and opening issues and PRs:

    The ApplicationSet controller would not exist without the contributions of these talented individuals! 🎉

    New in this Release

    List Generator

    The List generator generates parameters based on a fixed list of cluster name/URL values, with those values passed as parameters into the template. This allows manual control over Application destinations via editing of a literal list with the ApplicationSet.

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    spec:
     generators:
     - list:
         elements:
         - cluster: engineering-dev
           url: https://kubernetes.default.svc
    #    - cluster: engineering-prod
    #      url: (another cluster API url)
     template:
       spec:
         project: default
         source:
           repoURL: https://github.com/argoproj-labs/applicationset.git
           targetRevision: HEAD
           path: examples/list-generator/guestbook/{{cluster}}
         # (...)
    

    In this example, if one wanted to add a second cluster, we could uncomment the second cluster element and the ApplicationSet controller would automatically target it with the defined application.

    Cluster Generator

    The cluster generator is useful if you are using Argo CD to manage cluster add-ons, such as Custom Resource Definitions (CRDs) or Ingress Controllers, across a fleet of clusters. Instead of manually creating an application for each cluster, you can delegate it to the cluster generator.

    In Argo CD, managed clusters are stored within Secrets in the Argo CD namespace. The ApplicationSet controller uses those same Secrets to generate template parameters for which to target available clusters.

    The Cluster generator will automatically identify clusters defined with Argo CD, and extract the cluster data as parameters:

    kind: ApplicationSet
    spec:
      generators:
      - clusters: {} # Automatically use all clusters defined within Argo CD
      template:
        metadata:
          name: '{{name}}-guestbook' # 'name' field of the cluster
        spec:
          source: 
            # (...)
          destination:
            server: '{{server}}' # 'server' field of the cluster
            namespace: guestbook
    

    Git Directory Generator

    It is a good practice to define a convention between Argo CD application name and the location of the deployment manifests directory with the Git repository. For example, you might choose to store all manifests of production applications under "applications/prod/" and all staging applications under "applications/staging/".

    The Git Directory generator allows you to go one step further and "codify" that convention. The Git directory generator generates template parameters using the directory structure of a specified Git repository. Whenever a new subfolder is added to the Git repository, the ApplicationSet controller will detect this change and automatically use the subfolder path to template an Argo CD application containing the manifests contained within that folder (whether they be plain YAML, Kustomize, Helm, etc).

    kind: ApplicationSet
    spec:
      generators:
      - git:
          repoURL: https://github.com/argoproj-labs/applicationset.git
          revision: HEAD
          directories:
          - path: examples/git-generator-directory/cluster-addons/*
    # (...)
    

    Git File Generator

    Similar to the Directory generator, the Git File generator allows you to generate applications based on Git repository content but provide a bit more flexibility. The Git file generator generates template parameters using the contents of JSON files found within a specified repository. Git commits containing changes to JSON files are automatically discovered by the Git generator, and the contents of those files are parsed and converted into template parameters.

    This allows the creation of custom Argo CD Applications based on the contents of automatically discovered JSON files within the repository. As new files are added/changed, new Argo Applications are created or modified.

    kind: ApplicationSet
    spec:
      generators:
      - git:
          repoURL: https://github.com/argoproj-labs/applicationset.git
          revision: HEAD
          files:
          - path: "examples/git-generator-files-discovery/cluster-config/**/config.json"
    

    Brand new documentation and examples

    The ApplicationSet controller has a brand new set of documentation and examples. Topics include introduction, a quick getting started guide, use cases, the interaction with Argo CD, generators, template fields, application lifecycle, and more.

    Template Override

    In addition to specifying a template within the .spec.template of the ApplicationSet resource, templates may also be specified within generators. This is useful for overriding the values of the spec-level template with generator-specific values.

    spec:
      generators:
      - list:
          elements:
            - cluster: engineering-dev
              url: https://kubernetes.default.svc
          template: # <--- A template under a list generator
            metadata: {}
            spec:
              project: "default"
              source:
                revision: HEAD
                repoURL: https://github.com/argoproj-labs/applicationset.git
                # New path value is generated here:
                path: 'examples/template-override/{{cluster}}-override'
              destination: {}
    

    Support for arbitrary key/value pairs in Cluster generator and List generator

    Arbitrary key/value pairs may be included within the Cluster and List generators, which will be converted into template parameters during template rendering. This is useful for providing custom parameters for a specific generator instance:

    spec:
      generators:
      - clusters:
          values:
            version: '2.0.0'
    

    Bugs, tests, and infrastructure improvements

    In addition to the above new features, we delivered lots of bug fixes, new unit tests, a new end-to-end test framework, new end-to-end tests, a new release process, and build/test infrastructure improvements.

    Installation

    The ApplicationSet controller must be installed into the same namespace as the Argo CD it is targetting:

    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj-labs/applicationset/v0.1.0/manifests/install.yaml
    

    Once installed, the ApplicationSet controller requires no additional setup. You can learn more about ApplicationSet controller installation from the Getting Started page.

    Changelog

    Features:

    • Add item list CRD Spec (#1)
    • Sketch out cluster generator in the CRD, and generator interface (#2)
    • Add list generator support (#3)
    • Add git directory crd (#4)
    • Add git directory generator (#7)
    • Cluster Generator reconciling on cluster secret events (#8)
    • Create applications (#9)
    • feat(cluster-generator): allow templating of app labels (#24)
    • feat(cluster-generator): support matchExpressions in selectors (#25)
    • Improve controller error handling and logging. (#42)
    • Implement Git files discovery (#45)
    • add SyncPolicy (#48)
    • Add dry run option (#50)
    • add requeueAfter option (#51)
    • Add template override (#56)
    • Add support to metadata.annotations in the template (#58)
    • feat(cluster-generator): support arbitrary key:value pairs (#91)
    • Add support for support arbitrary key:value pairs in ListGenerator (#110)
    • Kustomize integration of Application Set controller and Argo CD (#113)

    Docs and examples:

    • 'User guide' docs: the whats/whys/hows of ApplicationSet controller documentation (#84)
    • 'User guide' docs: how to use ApplicationSet controller (examples of generators, template fields) documentation (#85)
    • User guide docs: how to use ApplicationSet controller, whats/whys/hows, examples (#117)
    • Improve and document the developer deployment process. (#37)
    • Expand on existing developer docs: how to setup dev env and how to run ApplicationSet controller on local machine (#74) (#90)
    • Making examples more clear (#111)
    • Add readthedocs/mkdocs integration to the documentation (#130)
    • Fix template-overrides-example.yaml (#144)

    Tests:

    • Add build and test GH action, fix TestGetApps race condition (#83) (#64)
    • Implement E2E test framework for testing ApplicationSet against live Kubernetes/Argo CD instance (#65) (#66)
    • Intermittent test failure in 'TestGitGenerateParamsFromFiles/handles_error_during_getting_repo_file_contents' (#96)
    • Add E2E tests for the git file generator (#138)
    • Write tests for pkg/utils/util.go (#146)
    • Write tests for clustereventhandler.go (#147)

    Bugs:

    • fix(list-generator): return generated applications (#21)
    • Fix rbac error listing Secrets at cluster scope. (#38)
    • Fix missing Application RBAC. (#39)
    • Log warning if applicationset contains unrecognized generators (#67)
    • The --namespace controller param and NAMESPACE environment variable should override to produce one canonical value (#70) (#109)
    • Cluster generator cannot select local cluster (#116)
    • Fix leader election (#125)
    • Git Directory Generator only matches directories that contain valid Helm/ksonnet/Kustomize artifacts (#132)
    • Prevent ApplicationSet controller from creating invalid Applications, causing 'unable to delete application resource' in Argo CD (#136)
    • Git generator may never detect new commits, if using default 'GetRequeueAfter' value (#137)
    • 'Error generating params' error when using JSON array in Git files generator file (#139)
    • 'appprojects.argoproj.io is forbidden' error from serviceaccount argocd-applicationset-controller (#141)
    • Applicationset-controller overloads api-server and have memory leak (#153)
    • Annotations set in application-set not updating apps (#156)
    • Git helpers missing from image (#160)
    • ApplicationSet does not support private repos configured using SSH (#163)
    • Workaround Argo CD cluster deletion reconciliation bug (#170)

    Tasks:

    • Update applications & add owner reference (#10)
    • Refactor the create application method so it will also do update and delete. (#11)
    • Reorg manifests & create kustomizations (#20)
    • Refactor - Making testing & writing generators more easy (#26)
    • Drop cluster-wide RBAC install and fix finalizer permissions issue. (#53)
    • Add Apache 2 LICENSE file. (#54)
    • Refine ApplicationSet SyncPolicy API to be less like ArgoCD. (#55)
    • Fix make deploy step (#60)
    • Add go fmt workflow, and go fmt the code (#62)
    • Add .golangci.yml from Argo CD, and fix corresponding linter failures (#63)
    • Raise error for duplicate application names (#69)
    • Sync go.(mod/sum) with argo-cd 1.8 release (#89)
    • Re-bootstrap of the project using kubebuilder 2 (#93)
    • Add 'lint-go' and 'go mod tidy' to GitHub actions (#95)
    • Setup release build scripts/artifacts for ApplicationSet controller releases (#105)
    • Kustomize Argo CD integration (and GitHub E2E test action) should use a fixed Argo CD version (#119)
    • Use apiextensions.k8s.io/v1 CustomResourceDefinition, rather than deprecated v1beta1 (#128)
    • Update test/generation Argo CD target version to v1.8.5 (#134)
    • Adopt same base image as Argo CD to fix vulnerability scan issues (#151)
    Source code(tar.gz)
    Source code(zip)
Notifications for Argo CD

Argo CD Notifications Argo CD Notifications continuously monitors Argo CD applications and provides a flexible way to notify users about important cha

argoproj-labs 456 Nov 27, 2022
Automatic container image update for Argo CD

Argo CD Image Updater Introduction Argo CD Image Updater is a tool to automatically update the container images of Kubernetes workloads which are mana

argoproj-labs 728 Dec 5, 2022
A Kubernetes operator for managing Argo CD clusters.

Argo CD Operator A Kubernetes operator for managing Argo CD clusters. Documentation See the documentation for installation and usage of the operator.

argoproj-labs 354 Nov 25, 2022
Support for extending Argo CD

Argo CD Extensions To enable Extensions for your Argo CD cluster will require just a single kubectl apply. Here we provide a way to extend Argo CD suc

argoproj-labs 66 Nov 30, 2022
Argo-CD Autopilot

Introduction New users to GitOps and Argo CD are not often sure how they should structure their repos, add applications, promote apps across environme

argoproj-labs 507 Dec 5, 2022
Hera is a Python framework for constructing and submitting Argo Workflows.

Hera is an Argo Workflows Python SDK. Hera aims to make workflow construction and submission easy and accessible to everyone! Hera abstracts away workflow setup details while still maintaining a consistent vocabulary with Argo Workflows.

argoproj-labs 231 Nov 27, 2022
A series of controllers for configuring namespaces to accomodate Argo

argo-controller A series of controllers for configuring namespaces to accomodate Argo. ArgoCD TBD Argo Workflows Make a service account in every names

Statistics Canada - Statistique Canada 0 Jan 4, 2022
Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes.

What is Argo Workflows? Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes. Argo Workflow

null 0 Dec 10, 2021
Argo Rollout visualization in Argo CD Web UI

Rollout Extension The project introduces the Argo Rollout dashboard into the Argo CD Web UI. Quick Start Install Argo CD and Argo CD Extensions Contro

argoproj-labs 80 Nov 30, 2022
Image clone controller is a kubernetes controller to safe guard against the risk of container images disappearing

Image clone controller image clone controller is a kubernetes controller to safe guard against the risk of container images disappearing from public r

Jayadeep KM 0 Oct 10, 2021
A Controller written in kubernetes sample-controller style which watches a custom resource named Bookstore

bookstore-sample-controller A Controller written in kubernetes sample-controller style which watches a custom resource named Bookstore. A resource cre

Abdullah Al Shaad 0 Jan 20, 2022
Automating Kubernetes Rollouts with Argo and Prometheus. Checkout the demo URL below

observe-argo-rollout Demo for Automating and Monitoring Kubernetes Rollouts with Argo and Prometheus Performing Demo The demo can be found on Katacoda

null 33 Nov 16, 2022
A plugin for argo which behaves like I'd like

argocd-lovely-plugin An ArgoCD plugin to perform various manipulations in a sensible order to ultimately output YAML for Argo CD to put into your clus

null 112 Nov 28, 2022
Simple example using Git actions + Argo CD + K8S + Docker and GO lang

CICD-simple_example Simple example using Git actions + Argo CD + K8S + Docker and GO lang Intro Pre reqs Have an ArgoCD account and Installed. Docker

Diogo Miyake 1 Oct 28, 2021
Notifications for Argo CD

Argo CD Notifications Argo CD Notifications continuously monitors Argo CD applications and provides a flexible way to notify users about important cha

argoproj-labs 456 Nov 27, 2022
Automatic container image update for Argo CD

Argo CD Image Updater Introduction Argo CD Image Updater is a tool to automatically update the container images of Kubernetes workloads which are mana

argoproj-labs 728 Dec 5, 2022
A Kubernetes operator for managing Argo CD clusters.

Argo CD Operator A Kubernetes operator for managing Argo CD clusters. Documentation See the documentation for installation and usage of the operator.

argoproj-labs 354 Nov 25, 2022
Support for extending Argo CD

Argo CD Extensions To enable Extensions for your Argo CD cluster will require just a single kubectl apply. Here we provide a way to extend Argo CD suc

argoproj-labs 66 Nov 30, 2022
Argo-CD Autopilot

Introduction New users to GitOps and Argo CD are not often sure how they should structure their repos, add applications, promote apps across environme

argoproj-labs 507 Dec 5, 2022
Hera is a Python framework for constructing and submitting Argo Workflows.

Hera is an Argo Workflows Python SDK. Hera aims to make workflow construction and submission easy and accessible to everyone! Hera abstracts away workflow setup details while still maintaining a consistent vocabulary with Argo Workflows.

argoproj-labs 231 Nov 27, 2022