Action Required: Fix Renovate Configuration

argocd-commenter

This is a Kubernetes Controller to notify a change of Argo CD Application status.

Example: Pull Request notification

In the GitOps way, you merge a pull request to deploy a change to Kubernetes cluster. argocd-commenter allows you to receive a notification comment after merging.

When an Application is syncing, synced or healthy, argocd-commenter will create a comment.

When the sync was failed, argocd-commenter will create a comment.

See the examples in e2e-test fixtures.

Sequence diagram

Here is the sequence diagram of the deployment flow.

sequenceDiagram
  actor User

  User ->>+ GitHub Repository: git push
  GitHub Repository -->>- User: pushed

  loop Argo CD reconciler
    Argo CD Application ->>+ GitHub Repository: git checkout
    GitHub Repository -->>- Argo CD Application: manifest
    note over Argo CD Application: Out of Sync
    Argo CD Application ->>+ Kubernetes Deployment: kubectl apply
    note over Argo CD Application: Syncing
    Kubernetes Deployment -->>- Argo CD Application: applied
    note over Argo CD Application: Synced
  end

  loop Kubernetes reconciler
    Kubernetes Deployment ->>+ Kubernetes Pod: create
    note over Argo CD Application: Progressing
    Kubernetes Pod -->>- Kubernetes Deployment: ready
    note over Argo CD Application: Healthy
  end

Example: GitHub Deployment notification

In a complex deployment flow, you can receive a notification using GitHub Deployments API. For example, when you deploy a preview environment for a pull request, you can receive the deployment statuses.

To receive a deployment status, set the following annotation to the Argo CD Application:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  annotations:
    argocd-commenter.int128.github.io/deployment-url: https://api.github.com/repos/OWNER/REPO/deployments/ID

Here is an example of workflow to deploy a preview environment:

jobs:
  deploy:
    steps:
      # Create a deployment
      - uses: int128/deployment-action@v1
        id: deployment

      # Generate the manifests for a preview environment
      - uses: actions/checkout@v2
        with:
          repository: your/manifests-repository
          path: manifests-repository
          token: # PAT or GitHub App token is required to write
      - run: |
          cp -a manifests "manifests-repository/pr-${{ github.event.pull_request.number }}"
          cd "manifests-repository/pr-${{ github.event.pull_request.number }}"
          sed -e 's|DEPLOYMENT_URL|${{ steps.deployment.outputs.url }}|g' applications/*.yaml

      # Push the manifests for a preview environment
      - run: |
          git add .
          git commit -m 'Deploy pr-${{ github.event.pull_request.number }}'
          git push manifests-repository main

When the Application status is changed, argocd-commenter will create a deployment status.

See the e2e test for details.

Sequence diagram

Here is the sequence diagram of the deployment flow.

sequenceDiagram
  actor User

  User ->>+ Application Repository: git push
  Application Repository -->>- User: pushed

  Application Repository ->>+ GitHub Actions: start
  GitHub Actions ->>+ GitHub Deployment: create
  GitHub Deployment -->>- GitHub Actions: created
  note over GitHub Deployment: Pending
  GitHub Actions ->>+ Manifest Repository: git push
  Manifest Repository -->>- GitHub Actions: pushed
  GitHub Actions -->>- Application Repository: success

  loop Argo CD reconciler
    Argo CD Application ->>+ Manifest Repository: git checkout
    Manifest Repository -->>- Argo CD Application: manifest
    note over Argo CD Application: Out of Sync
    note over GitHub Deployment: Queued
    Argo CD Application ->>+ Kubernetes Deployment: kubectl apply
    note over Argo CD Application: Syncing
    Kubernetes Deployment -->>- Argo CD Application: applied
    note over Argo CD Application: Synced
    note over GitHub Deployment: In progress
  end

  loop Kubernetes reconciler
    Kubernetes Deployment ->>+ Kubernetes Pod: create
    note over Argo CD Application: Progressing
    Kubernetes Pod -->>- Kubernetes Deployment: ready
    note over Argo CD Application: Healthy
    note over GitHub Deployment: Active
  end

Getting Started

Prerequisite

Argo CD is running in your Kubernetes cluster.

Setup

To deploy the manifest:

kubectl apply -f https://github.com/int128/argocd-commenter/releases/download/v1.8.0/argocd-commenter.yaml

You need to create either Personal Access Token or GitHub App.

Personal Access Token
- Belong to a user
- Share the rate limit in a user
GitHub App
- Belong to a user or organization
- Have each rate limit for an installation

Option 1: Using a Personal Access Token

Open https://github.com/settings/tokens
Generate a new token

Create a secret as follows:

kubectl -n argocd-commenter-system create secret generic controller-manager \
  --from-literal="GITHUB_TOKEN=$YOUR_PERSONAL_ACCESS_TOKEN"

Option 2: Using a GitHub App

Create your GitHub App from either link:
- For a user: https://github.com/settings/apps/new?name=argocd-commenter&url=https://github.com/int128/argocd-commenter&webhook_active=false&contents=read&pull_requests=write
- For an organization: https://github.com/organizations/:org/settings/apps/new?name=argocd-commenter&url=https://github.com/int128/argocd-commenter&webhook_active=false&contents=read&pull_requests=write (replace :org with your organization)
Get the App ID from the setting page
Download a private key of the GitHub App
Set a custom badge for the GitHub App
- Logo of Argo CD is available in CNCF Branding
Install your GitHub App on your repository or organization
Get the Installation ID from the URL, like https://github.com/settings/installations/ID

Create a secret as follows:

kubectl -n argocd-commenter-system create secret generic controller-manager \
  --from-literal="GITHUB_APP_ID=$YOUR_GITHUB_APP_ID" \
  --from-literal="GITHUB_APP_INSTALLATION_ID=$YOUR_GITHUB_APP_INSTALLATION_ID" \
  --from-file="GITHUB_APP_PRIVATE_KEY=/path/to/private-key.pem"

Verify setup

Make sure the controller is running.

kubectl -n argocd-commenter-system rollout status deployment argocd-commenter-controller-manager

Configuration

GitHub Enterprise Server

Set the environment variable GITHUB_ENTERPRISE_URL.

kubectl -n argocd-commenter-system create secret generic controller-manager \
  --from-literal="GITHUB_TOKEN=$YOUR_PERSONAL_ACCESS_TOKEN" \
  --from-literal="GITHUB_ENTERPRISE_URL=$YOUR_GITHUB_ENTERPRISE_URL"

Contribution

This is an open source software. Feel free to contribute to it.

	func isPullRequestRelatedToEvent(pull github.PullRequest, app argocdv1alpha1.Application) bool {
	if app.Spec.Source == nil {
	return false
	}

	// support manifest path annotation
	// see https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/#webhook-and-manifest-paths-annotation
	// https://github.com/int128/argocd-commenter/pull/656
	manifestGeneratePaths := getManifestGeneratePaths(app)

	for _, file := range pull.Files {
	if strings.HasPrefix(file, app.Spec.Source.Path) {
	return true
	}
	for _, path := range manifestGeneratePaths {
	if strings.HasPrefix(file, path) {
	return true
	}
	}
	}
	return false
	}

	// getManifestGeneratePaths returns canonical paths of "argocd.argoproj.io/manifest-generate-paths" annotation.
	// It returns nil if the field is nil or empty.
	// https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/#webhook-and-manifest-paths-annotation
	func getManifestGeneratePaths(app argocdv1alpha1.Application) []string {
	if app.Annotations == nil {
	return nil
	}
	if app.Spec.Source == nil {
	return nil
	}
	var canonicalPaths []string
	annotatedPaths := strings.Split(app.Annotations["argocd.argoproj.io/manifest-generate-paths"], ";")
	for _, path := range annotatedPaths {
	if path == "" {
	return nil
	}
	// convert to absolute path
	absolutePath := path
	if !filepath.IsAbs(path) {
	absolutePath = filepath.Join(app.Spec.Source.Path, path)
	}
	// remove leading slash
	if absolutePath[0:1] == "/" {
	absolutePath = absolutePath[1:]
	}
	// add to list of manifest paths
	canonicalPaths = append(canonicalPaths, absolutePath)
	}
	return canonicalPaths
	}

	var q struct {
	Repository struct {
	Object struct {
	Commit struct {
	AssociatedPullRequests struct {
	Nodes []struct {
	ID githubv4.ID
	Number int
	}
	} `graphql:"associatedPullRequests(first: 1)"`
	} `graphql:"... on Commit"`
	} `graphql:"object(oid: $commitSHA)"`
	} `graphql:"repository(owner: $owner, name: $name)"`
	}

	func NewCommentOnOnPhaseChanged(app argocdv1alpha1.Application, argocdURL string) *Comment {
	repository := github.ParseRepositoryURL(app.Spec.Source.RepoURL)
	if repository == nil {
	return nil
	}
	revision := argocd.GetDeployedRevision(app)
	if revision == "" {
	return nil
	}
	body := generateCommentOnPhaseChanged(app, argocdURL)
	if body == "" {
	return nil
	}
	return &Comment{
	GitHubRepository: *repository,
	Revision: revision,
	Body: body,
	}
	}

	func GetDeployedRevision(a argocdv1alpha1.Application) string {
	if a.Status.OperationState == nil {
	return ""
	}
	if a.Status.OperationState.Operation.Sync == nil {
	return ""
	}
	return a.Status.OperationState.Operation.Sync.Revision
	}

	var patternDeploymentURL = regexp.MustCompile(`^https://api\.github\.com/repos/(.+?)/(.+?)/deployments/(\d+)$`)

	// ParseDeploymentURL parses the URL.
	// For example, https://api.github.com/repos/int128/sandbox/deployments/422988781
	func ParseDeploymentURL(s string) *Deployment {
	m := patternDeploymentURL.FindStringSubmatch(s)
	if len(m) != 4 {
	return nil
	}

	// When an application is synced but the health status is not changed,
	// the controller will evaluate the health status after this time.
	requeueTimeToEvaluateHealthStatusAfterSyncOperation = 3 * time.Second

	var (
	patternRepositoryHTTPS = regexp.MustCompile(`^https://github\.com/([^/]+?)/([^/]+?)(\.git)?$`)
	patternRepositorySSH = regexp.MustCompile(`^git@github\.com:([^/]+?)/([^/]+?)(\.git)?$`)
	)

int128 / argocd-commenter Goto Github PK

argocd-commenter's Introduction

argocd-commenter

Example: Pull Request notification

Sequence diagram

Example: GitHub Deployment notification

Sequence diagram

Getting Started

Prerequisite

Setup

Option 1: Using a Personal Access Token

Option 2: Using a GitHub App

Verify setup

Configuration

GitHub Enterprise Server

Contribution

argocd-commenter's People

Contributors

Stargazers

Watchers

Forkers

argocd-commenter's Issues

Problem to solve

How to solve

Problem to solve

How to solve

Context

Where argocd-commenter comes in

Additional information

Problem to solve

Applications structure

Scenario

How to solve

Problem to solve

Open

Detected dependencies

Problem to solve

How to solve

Problem

Solution

Related issue

Design

Relationship

Recommend Projects

Recommend Topics

Recommend Org