Model custom path

.github/OWNERS

@@ -5,3 +5,4 @@ approvers:
 reviewers:
   - rimolive
   - droctothorpe
+  - gmfrasca

.github/actions/create-cluster/action.yml

@@ -0,0 +1,22 @@
+name: "Set up KFP on KinD"
+description: "Step to start and configure KFP on Kind"
+
+inputs:
+  k8s_version:
+    description: "The Kubernetes version to use for the Kind cluster"
+    required: true
+  cluster_name:
+    description: "Provide kind cluster name if you want to name it other than kfp"
+    required: false
+    default: 'kfp'
+
+runs:
+  using: "composite"
+  steps:
+    - name: Create k8s Kind Cluster
+      uses: container-tools/kind-action@v2
+      with:
+        cluster_name: ${{ inputs.cluster_name }}
+        kubectl_version: ${{ inputs.k8s_version }}
+        version: v0.25.0
+        node_image: kindest/node:${{ inputs.k8s_version }}

.github/actions/deploy/action.yml

@@ -0,0 +1,133 @@
+name: "Set up KFP on KinD"
+description: "Step to start and configure KFP on Kind"
+
+inputs:
+  pipeline_store:
+    description: "Flag to deploy KFP with K8s Native API"
+    default: 'database'
+    required: false
+  proxy:
+    description: "If KFP should be deployed with proxy configuration"
+    required: false
+    default: 'false'
+  cache_enabled:
+    description: "If KFP should be deployed with cache enabled globally"
+    required: false
+    default: 'true'
+  image_tag:
+    required: true
+    description: "Provide the image tag your image was tagged with"
+  image_path:
+    required: true
+    description: "Path within github artifacts where your image tarball is stored"
+  image_registry:
+    required: true
+    description: "Image Registry address of the images"
+  multi_user:
+    description: "If KFP should be deployed in multi-user mode"
+    required: false
+    default: 'false'
+  artifact_proxy:
+    description: "Enables artifact proxy"
+    required: false
+    default: 'false'
+  storage_backend:
+    description: "Storage backend to use (minio or seaweedfs)"
+    required: false
+    default: 'seaweedfs'
+  argo_version:
+    required: false
+    description: "Argo version to use for the cluster"
+  forward_port:
+    required: false
+    default: 'true'
+    description: "If you want to forward API server port to localhost:8888"
+  pod_to_pod_tls_enabled:
+    description: "If KFP should be deployed with TLS pod-to-pod communication."
+    required: false
+    default: 'false'
+
+runs:
+  using: "composite"
+  steps:
+    - name: Deploy Squid
+      id: deploy-squid
+      if: ${{ inputs.proxy == 'true' }}
+      shell: bash
+      run: ./.github/resources/squid/deploy-squid.sh
+
+    - name: Download Docker Images
+      uses: actions/download-artifact@v4
+      with:
+        path: "images_${{ github.sha }}"
+
+    - name: Load Docker Images
+      shell: bash
+      run: |
+        APPS=("apiserver" "driver" "launcher" "scheduledworkflow" "persistenceagent" "frontend" "metadata-writer")
+        for app in "${APPS[@]}"; do
+          docker image load -i ${{ inputs.image_path }}/$app/$app.tar
+          docker push ${{ inputs.image_registry }}/$app:${{ inputs.image_tag }}
+          rm ${{ inputs.image_path }}/$app/$app.tar
+          docker image rm ${{ inputs.image_registry }}/$app:${{ inputs.image_tag }}
+        done  
+
+    - name: Configure Args
+      shell: bash
+      id: configure
+      run: |
+        ARGS=""
+
+        if [ "${{ inputs.proxy }}" = "true" ]; then
+          echo "Enabling Proxy"
+          ARGS="${ARGS} --proxy"
+        fi
+
+        if [ "${{inputs.cache_enabled }}" = "false" ]; then
+          echo "Disabling Cache"
+          ARGS="${ARGS} --cache-disabled"
+        fi
+
+        if [ "${{inputs.pipeline_store }}" = "kubernetes" ]; then
+          echo "Deploying in native K8s API Mode"
+          ARGS="${ARGS} --deploy-k8s-native"
+        fi
+
+        if [ "${{ inputs.multi_user }}" = "true" ]; then
+          echo "Deploying in Multi User Mode"
+          ARGS="${ARGS} --multi-user"
+        fi
+
+        if [ "${{ inputs.artifact_proxy }}" = "true" ]; then
+          echo "Enabling artifact proxy"
+          ARGS="${ARGS} --artifact-proxy"
+        fi
+
+        if [ "${{ inputs.storage_backend }}" != "seaweedfs" ] && [ -n "${{ inputs.storage_backend }}" ]; then
+          echo "Deploying with artifact storage ${{ inputs.storage_backend }}"
+          ARGS="${ARGS} --storage ${{ inputs.storage_backend }}"
+        fi
+
+        if [ -n "${{ inputs.argo_version }}" ]; then
+          echo "Deploying with argo version ${{ inputs.argo_version }}"
+          ARGS="${ARGS} --argo-version ${{ inputs.argo_version }}"
+        fi
+        if [ "${{inputs.pod_to_pod_tls_enabled }}" = "true" ]; then
+          ARGS="${ARGS} --tls-enabled"
+        fi
+        echo "ARGS=$ARGS" >> $GITHUB_OUTPUT
+
+    - name: Deploy KFP
+      id: deploy-kfp
+      if: ${{ steps.configure.outcome == 'success' }}
+      uses: nick-fields/retry@ce71cc2ab81d554ebbe88c79ab5975992d79ba08
+      with:
+        max_attempts: 2
+        timeout_minutes: 15
+        command: ./.github/resources/scripts/deploy-kfp.sh ${{ steps.configure.outputs.ARGS }}
+
+    - name: Forward API port
+      id: forward-api-port
+      shell: bash
+      if: ${{ steps.deploy-kfp.outcome == 'success' && inputs.forward_port == 'true'}}
+      run: ./.github/resources/scripts/forward-port.sh "kubeflow" "ml-pipeline" 8888 8888

.github/actions/kfp-k8s/action.yml

@@ -0,0 +1,47 @@
+name: "Install kfp & kfp-kubernetes"
+inputs:
+  build_version:
+    required: true
+    default: "1.2.2"
+    description: "build package version"
+  generate_golang_proto:
+    required: true
+    default: "false"
+    description: "optionally generate golang proto files"
+runs:
+  using: "composite"
+  steps:
+    - name: Install build tool
+      shell: bash
+      run: pip install build==${{inputs.build_version}}
+
+    - name: Build kfp dist
+      id: install-kfp
+      shell: bash
+      working-directory: sdk/python
+      run: |
+        python -m build .
+
+    - name: Generate kfp-kubernetes python proto files from source
+      id: generate-kfp-kubernetes-proto-files
+      shell: bash
+      if: ${{ steps.install-kfp.outcome == 'success' }}
+      working-directory: ./kubernetes_platform
+      run: make clean python USE_FIND_LINKS=true
+
+    - name: Generate kfp-kubernetes golang proto files from source
+      id: generate-kfp-kubernetes-go-proto-files
+      shell: bash
+      if: ${{ steps.install-kfp.outcome == 'success' && inputs.generate_golang_proto == 'true' }}
+      working-directory: ./kubernetes_platform
+      run: make golang
+
+    # kfp is installed transitively
+    # --find-links ensures pip first looks in the sdk/python/dist folder
+    # outputted from generate-kfp-kubernetes-proto-files step before looking at pypi
+    - name: Install kfp & kfp-kubernetes from source
+      id: install-kfp-kubernetes
+      shell: bash
+      if: ${{ steps.generate-kfp-kubernetes-proto-files.outcome == 'success' }}
+      run: |
+        pip install -e ./kubernetes_platform/python[dev] --find-links=sdk/python/dist

.github/actions/protobuf/action.yml

@@ -0,0 +1,81 @@
+name: "Install Proto dependencies & Pipeline Spec"
+description: |
+  This action pins various Proto generation packages to default versions and
+  installs these dependencies in the workflow environment. It will also 
+  install the kfp-pipeline-spec. Whenever KFP project updates generation 
+  packages, the defaults here must be updated.
+inputs:
+  protoc_version:
+    required: true
+    default: "31.1"
+    description: "protoc version"
+  protobuf_python_version:
+    required: true
+    default: "6.31.1"
+    description: "protobuf python package version"
+  setuptools_version:
+    required: true
+    default: "80.9.0"
+    description: "setuptools python package version"
+  wheels_version:
+    required: true
+    default: "0.42.0"
+    description: "wheels python package version"
+  generate_golang_proto:
+    required: true
+    default: "false"
+    description: "optionally generate golang proto files"
+runs:
+  using: "composite"
+  steps:
+    - name: Install protoc
+      shell: bash
+      run: |
+        PROTOC_ZIP=protoc-${{inputs.protoc_version}}-linux-x86_64.zip
+        curl -sSL -O https://github.com/protocolbuffers/protobuf/releases/download/v${{inputs.protoc_version}}/$PROTOC_ZIP
+        sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
+        sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
+        rm $PROTOC_ZIP
+        protoc --version
+
+    - name: Install setuptools
+      shell: bash
+      run: |
+        pip3 install setuptools==${{inputs.setuptools_version}}
+        pip3 freeze
+
+    - name: Install Wheel
+      shell: bash
+      run: pip3 install wheel==${{inputs.wheels_version}}
+    - name: Install protobuf
+      shell: bash
+      run: pip3 install protobuf==${{inputs.protobuf_python_version}}
+    - name: Generate API proto files
+      working-directory: ./api
+      shell: bash
+      run: make clean python
+    - name: Install kfp-pipeline-spec from source
+      shell: bash
+      run: |
+        pip install api/v2alpha1/python/dist/*.whl
+
+    - name: Generate kfp-pipeline-spec golang files
+      if: ${{ inputs.generate_golang_proto == 'true' }}
+      working-directory: ./api
+      shell: bash
+      run: |
+        make golang
+
+    - name: Summary
+      shell: bash
+      run: |
+        cat <<EOF
+        Installed the following dependencies:
+        Binaries:
+          protoc: ${{ inputs.protoc_version }}
+        Python Packages:
+          setuptools: ${{ inputs.setuptools_version }}
+          wheels: ${{ inputs.wheels_version }}
+          protobuf: ${{ inputs.protobuf_python_version }}
+        EOF
+