Adding new pattern for Crossplane Argocd GitOps

bin/crossplane-argocd-gitops.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import * as cdk from 'aws-cdk-lib';
+import { errorHandler } from '../lib/common/construct-utils';
+import MultiClusterPipelineConstruct from "../lib/crossplane-argocd-gitops/multi-cluster-pipeline";
+
+const app = new cdk.App();
+
+new MultiClusterPipelineConstruct().buildAsync(app,  "crossplane-argocd-gitops").catch((e) => {
+    errorHandler(app, "Pipeline construct failed because of error: ", e);
+});

docs/patterns/kubeflow.md

@@ -70,7 +70,7 @@ kubectl port-forward svc/ml-pipeline-ui 9000:80 -n =kubeflow-pipelines
 
 ```
 and open this browser: http://localhost:9000/#/pipelines
-more pipeline examples can be found at https://www.kubeflow.org/docs/components/pipelines/tutorials/
+more pipeline examples can be found at https://www.kubeflow.org/docs/components/pipelines/
 
 
 ## Cleanup

lib/crossplane-argocd-gitops/custom-addons/crossplane-helm-provider-addon.ts

@@ -0,0 +1,79 @@
+import 'source-map-support/register';
+import * as blueprints from '@aws-quickstart/eks-blueprints';
+import * as eks from "aws-cdk-lib/aws-eks";
+import { Construct } from 'constructs';
+import { dependable } from '@aws-quickstart/eks-blueprints/dist/utils';
+import { UpboundCrossplaneAddOn } from './upbound-crossplane-addon';
+
+export class CrossplaneHelmProviderAddon implements blueprints.ClusterAddOn {
+    id?: string | undefined;
+    @dependable(UpboundCrossplaneAddOn.name)
+    deploy(clusterInfo: blueprints.ClusterInfo): void | Promise<Construct> {
+        const cluster = clusterInfo.cluster;
+
+        const role_binding = {
+            apiVersion: "rbac.authorization.k8s.io/v1",
+            kind: "ClusterRoleBinding",
+            metadata: { 
+                name: "helm-provider"             
+            },
+            subjects: [
+                {
+                    kind: "ServiceAccount",
+                    name: "helm-provider",
+                    namespace: "upbound-system"
+                }
+            ],
+            roleRef: {
+                kind: "ClusterRole",
+                name: "cluster-admin",
+                apiGroup: "rbac.authorization.k8s.io"
+            }
+        };
+
+        const runtime_config = {
+            apiVersion: "pkg.crossplane.io/v1beta1",
+            kind: "DeploymentRuntimeConfig",
+            metadata: { 
+                name: "helm-runtime-config"               
+            },
+            spec: {
+                deploymentTemplate: {
+                    spec: { 
+                        replicas: 1,
+                        selector: {},
+                        template: {}
+                    }
+                },
+                serviceAccountTemplate: { 
+                    metadata: { name: "helm-provider" } 
+                }
+            }
+        };
+
+        const provider = {
+            apiVersion: "pkg.crossplane.io/v1",
+            kind: "Provider",
+            metadata: { name: "helm-provider" },
+            spec: {
+                package: "xpkg.upbound.io/crossplane-contrib/provider-helm:v0.18.1",
+                runtimeConfigRef: {
+                    name: "helm-runtime-config"
+                }
+            }
+        };
+
+        const runtimeHelmConfig = new eks.KubernetesManifest(clusterInfo.cluster.stack, "runtimeHelmConfig", {
+            cluster: cluster,
+            manifest: [role_binding, runtime_config]
+        });
+
+        const awsHelmProvider = new eks.KubernetesManifest(clusterInfo.cluster.stack, "providerHelmResource", {
+            cluster: cluster,
+            manifest: [provider]
+        });
+
+        awsHelmProvider.node.addDependency(runtimeHelmConfig);
+        return Promise.resolve(runtimeHelmConfig);
+    }
+}

lib/crossplane-argocd-gitops/custom-addons/crossplane-k8s-provider-addon.ts

@@ -0,0 +1,85 @@
+import 'source-map-support/register';
+import * as blueprints from '@aws-quickstart/eks-blueprints';
+import * as eks from "aws-cdk-lib/aws-eks";
+import { Construct } from 'constructs';
+import { dependable } from '@aws-quickstart/eks-blueprints/dist/utils';
+import { UpboundCrossplaneAddOn } from './upbound-crossplane-addon';
+
+export class CrossplaneK8sProviderAddon implements blueprints.ClusterAddOn {
+    id?: string | undefined;
+    readonly k8sProviderVersion: string;
+    constructor(k8sProviderVersion: string) {
+        this.k8sProviderVersion = k8sProviderVersion;
+    }
+
+    @dependable(UpboundCrossplaneAddOn.name)
+    deploy(clusterInfo: blueprints.ClusterInfo): void | Promise<Construct> {
+        const cluster = clusterInfo.cluster;
+
+        const role_binding1 = {
+            apiVersion: "rbac.authorization.k8s.io/v1",
+            kind: "ClusterRoleBinding",
+            metadata: { name: "kubernetes-provider" },
+            subjects: [
+                {
+                    kind: "ServiceAccount",
+                    name: "kubernetes-provider",
+                    namespace: "upbound-system"
+                }
+            ],
+            roleRef: {
+                kind: "ClusterRole",
+                name: "cluster-admin",
+                apiGroup: "rbac.authorization.k8s.io"
+            }
+        };
+
+        const runtime_config1 = {
+            apiVersion: "pkg.crossplane.io/v1beta1",
+            kind: "DeploymentRuntimeConfig",
+            metadata: { 
+                name: "kubernetes-runtime-config"              
+            },
+            spec: {
+                deploymentTemplate: {
+                    spec: { 
+                        replicas: 1,
+                        selector: {},
+                        template: {}
+                    }
+                },
+                serviceAccountTemplate: { 
+                    metadata: { name: "kubernetes-provider" } 
+                }
+            }
+        };
+
+        const providerK8sResource1 = {
+            apiVersion: "pkg.crossplane.io/v1",
+            kind: "Provider",
+            metadata: { name: "kubernetes-provider" },
+            spec: {
+                // package: "xpkg.upbound.io/crossplane-contrib/provider-kubernetes:v0.13.0",
+                package: "xpkg.upbound.io/crossplane-contrib/provider-kubernetes:${this.k8sProviderVersion}",
+
+                runtimeConfigRef: {
+                    name: "kubernetes-runtime-config"
+                }
+            }
+        };
+
+        const runtimeK8sConfig1 = new eks.KubernetesManifest(clusterInfo.cluster.stack, "runtimeK8sConfig1", {
+            cluster: cluster,
+            manifest: [role_binding1, runtime_config1]
+        });
+
+        const awsK8sProvider1 = new eks.KubernetesManifest(clusterInfo.cluster.stack, "awsK8sProvider1", {
+            cluster: cluster,
+            manifest: [providerK8sResource1]
+        });
+
+        awsK8sProvider1.node.addDependency(runtimeK8sConfig1);
+
+        return Promise.resolve(runtimeK8sConfig1);
+    }
+}

lib/crossplane-argocd-gitops/custom-addons/mgmt-role-teams.ts

@@ -0,0 +1,13 @@
+
+import {PlatformTeam} from "@aws-quickstart/eks-blueprints";
+
+export class ProviderMgmtRoleTeam extends PlatformTeam {
+    constructor(accountID :string) {
+        // compute the ARN explicitly since we know its name
+        const computedProviderRoleArn = `arn:aws:iam::${accountID}:role/provider-aws-management-cluster`;
+        super( {
+            name: computedProviderRoleArn,
+            userRoleArn: computedProviderRoleArn
+        });
+    }
+}

lib/crossplane-argocd-gitops/custom-addons/upbound-crossplane-addon.ts

@@ -0,0 +1,89 @@
+import 'source-map-support/register';
+import * as blueprints from '@aws-quickstart/eks-blueprints';
+import { Construct } from 'constructs';
+import { Values } from "@aws-quickstart/eks-blueprints/dist/spi";
+import { merge } from "ts-deepmerge";
+import { createNamespace } from '@aws-quickstart/eks-blueprints/dist/utils';
+import { Policy, PolicyDocument} from 'aws-cdk-lib/aws-iam';
+import * as cdk from 'aws-cdk-lib';
+
+/**
+ * User provided options for the Helm Chart
+ */
+export interface UpboundCrossplaneAddOnProps extends blueprints.HelmAddOnUserProps {
+    /**
+     * To Create Namespace using CDK
+     */
+    createNamespace?: boolean;
+  }
+
+const defaultProps: blueprints.HelmAddOnProps = {
+    name: 'uxp',
+    release: 'blueprints-addon-uxp',
+    namespace: 'upbound-system',
+    chart: 'universal-crossplane',
+    version: '1.14.5-up.1',
+    repository: 'https://charts.upbound.io/stable',
+    values: {},
+};
+
+export class UpboundCrossplaneAddOn extends blueprints.HelmAddOn {
+
+    readonly options: UpboundCrossplaneAddOnProps;
+
+    constructor( props?: UpboundCrossplaneAddOnProps) {
+        super({...defaultProps, ...props});
+
+        this.options = this.props as UpboundCrossplaneAddOnProps;
+    }
+
+    deploy(clusterInfo: blueprints.ClusterInfo): void | Promise<Construct> {
+        const cluster = clusterInfo.cluster;
+
+        // Create the `upbound-system` namespace.
+        const ns = createNamespace(this.options.namespace!, cluster, true);
+
+        // Create the CrossPlane AWS Provider IRSA.
+        const serviceAccountName = "provider-aws";
+        const sa = cluster.addServiceAccount(serviceAccountName, {
+            name: serviceAccountName,
+            namespace: this.options.namespace!,
+
+        });
+        sa.node.addDependency(ns);
+        sa.role.attachInlinePolicy(new Policy(cluster.stack, 'eks-connect-policy',  {
+            document: PolicyDocument.fromJson({
+                "Version": "2012-10-17",
+                "Statement": [
+                    {
+                        "Effect": "Allow",
+                        "Action": ["sts:AssumeRole"],
+                        "Resource": `arn:aws:iam::${cluster.stack.account}:role/eks-connector-role`
+                    },
+                    {
+                        "Effect": "Allow",
+                        "Action": ["eks:*"],
+                        "Resource": `*`
+                    }                
+                ]
+            })}));
+
+        clusterInfo.addAddOnContext(UpboundCrossplaneAddOn.name, {
+            arn: sa.role.roleArn
+        });
+
+        new cdk.CfnOutput(cluster.stack, 'providerawssaiamrole',
+            {
+                value: sa.role.roleArn,
+                description: 'provider AWS IAM role',
+                exportName : 'providerawssaiamrole'
+            });
+
+        let values: Values = this.options.values ?? {};
+        values = merge(values, values);
+
+        const chart = this.addHelmChart(clusterInfo, values, false, true);
+        chart.node.addDependency(sa);
+        return Promise.resolve(chart);
+    }
+}

lib/crossplane-argocd-gitops/custom-addons/upbound-crossplane-eks-provider-addon.ts

@@ -0,0 +1,57 @@
+import 'source-map-support/register';
+import * as blueprints from '@aws-quickstart/eks-blueprints';
+import * as eks from "aws-cdk-lib/aws-eks";
+import { Construct } from 'constructs';
+import { dependable } from '@aws-quickstart/eks-blueprints/dist/utils';
+import { UpboundCrossplaneAddOn } from './upbound-crossplane-addon';
+
+export class UpboundCrossplaneEKSProviderAddOn implements blueprints.ClusterAddOn {
+    id?: string | undefined;
+    readonly UpboundEKSProviderVersion: string;
+    constructor(UpboundEKSProviderVersion: string) {
+        this.UpboundEKSProviderVersion = UpboundEKSProviderVersion;
+    }    
+    @dependable(UpboundCrossplaneAddOn.name)
+    deploy(clusterInfo: blueprints.ClusterInfo): void | Promise<Construct> {
+        const cluster = clusterInfo.cluster;
+        const crossplaneIRSARole = clusterInfo.getAddOnContexts().get("UpboundCrossplaneAddOn")!["arn"];
+        const controllerConfig = new eks.KubernetesManifest(clusterInfo.cluster.stack, "ControllerConfig", {
+            cluster: cluster,
+            manifest: [
+                {
+                    apiVersion: "pkg.crossplane.io/v1alpha1",
+                    kind: "ControllerConfig",
+                    metadata: {
+                        name: "aws-config",
+                        annotations: {
+                            "eks.amazonaws.com/role-arn": crossplaneIRSARole
+                        }
+                    },
+                    spec: {},
+                },
+            ],
+        });
+
+        const awsEksProvider = new eks.KubernetesManifest(clusterInfo.cluster.stack, "EKSProvider", {
+            cluster: cluster,
+            manifest: [
+                {
+                    apiVersion: "pkg.crossplane.io/v1",
+                    kind: "Provider",
+                    metadata: {
+                        name: "provider-aws-eks",
+                    },
+                    spec: {
+                        package: "xpkg.upbound.io/upbound/provider-aws-eks:${this.UpboundEKSProviderVersion}",
+                        controllerConfigRef: {
+                            name: "aws-config"
+                        }
+                    },
+                },
+            ],
+        });
+
+        awsEksProvider.node.addDependency(controllerConfig);
+        return Promise.resolve(controllerConfig);
+    }
+}