updated the description

* Added some tests, not sure what else to try but gonna think of more examples

* forgot some files

* reverted package-lock.json

* Added empty dir test

* Cleaned up some extra spaces

* Add node modules and compiled JavaScript from main

* forgot to actually include functionality

* removed unnecessary files

* Update .gitignore

* Update .gitignore

* Update .gitignore

* thx david

* renamed searchFilesRec

* integrations test fix

* added examples to README

* added note about depth

* added additional note

* removed ticks

* changed version string

* removed conflict on readme

* Added tests for bluegreen helper and resolved issue with ingress not being read correctly, still have to figure out why new services aren't showing up

* resolved services name issue

* looks functional, beginning refactor now

* refactored deploy methods for type error

* Removed refactor comments

* prettier

* implemented Oliver's feedback

* prettier

* added optional chaining operator

* removed refactor comment

Co-authored-by: Jaiveer Katariya <jaiveerkatariya@Jaiveers-MacBook-Pro.local>
Co-authored-by: Oliver King <oking3@uncc.edu>
Co-authored-by: Jaiveer Katariya <jaiveerkatariya@Jaiveers-MBP.lan>

.github/ISSUE_TEMPLATE/bugReportForm.yml

@@ -0,0 +1,28 @@
+name: Bug Report
+description: File a bug report, we will respond to this thread with any questions.
+title: 'Bug: '
+labels: ['bug', 'triage']
+assignees: '@Azure/aks-atlanta'
+body:
+   - type: input
+     id: What-happened
+     attributes:
+        label: What happened?
+        description: Tell us what happened and how is it different form the expected?
+        placeholder: Tell us what you see!
+     validations:
+        required: true
+   - type: input
+     id: Runner
+     attributes:
+        label: Runner
+        description: What runner are you using?
+        placeholder: Mention the runner info (self-hosted, operating system)
+     validations:
+        required: true
+   - type: input
+     id: Logs
+     attributes:
+        label: Relevant log output
+        description: Run in debug mode for the most verbose logs. Please feel free to attach a screenshot of the logs
+        render: shell

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,6 @@
+blank_issues_enabled: false
+contact_links:
+   - name: GitHub Action "aks-set-context" Support
+     url: https://github.com/Azure/aks-set-context
+     security: https://github.com/Azure/aks-set-context/blob/main/SECURITY.md
+     about: Please ask and answer questions here.

.github/ISSUE_TEMPLATE/featureRequestForm.yml

@@ -0,0 +1,13 @@
+name: Feature Request
+description: File a Feature Request form, we will respond to this thread with any questions.
+title: 'Feature Request: '
+labels: ['Feature']
+assignees: '@Azure/aks-atlanta'
+body:
+   - type: input
+     id: Feature request
+     attributes:
+        label: Feature request
+        description: Provide example functionality and links to relevant docs
+     validations:
+        required: true

README.md

@@ -96,6 +96,10 @@ Following are the key capabilities of this action:
     <td>version-switch-buffer </br></br>(Optional and relevant only if strategy is blue-green)</td>
     <td>Acceptable values: 1-300.</br>Default value: 0.</br>Waits for the given input in minutes before routing traffic to '-green' workloads.</td>
   </tr>
+  <tr>
+    <td>private-cluster </br></br>(Optional and relevant only using K8's deploy for a cluster with private cluster enabled)</td>
+    <td>Acceptable values: true, false</br>Default value: false.</td>
+  </tr>
   <tr>
     <td>force </br></br>(Optional)</td>
     <td>Deploy when a previous deployment already exists. If true then '--force' argument is added to the apply command. Using '--force' argument is not recommended in production.</td>
@@ -122,6 +126,26 @@ Following are the key capabilities of this action:
         image-pull-secret2
 ```
 
+### Private cluster deployment
+
+```yaml
+- uses: Azure/k8s-deploy@v4
+  with:
+     resource-group: yourResourceGroup
+     name: yourClusterName
+     action: deploy
+     strategy: basic
+
+     private-cluster: true
+     manifests: |
+        manifests/azure-vote-backend-deployment.yaml
+        manifests/azure-vote-backend-service.yaml
+        manifests/azure-vote-frontend-deployment.yaml
+        manifests/azure-vote-frontend-service.yaml
+     images: |
+        registry.azurecr.io/containername
+```
+
 ### Canary deployment without service mesh
 
 ```yaml

action.yml

@@ -62,6 +62,16 @@ inputs:
       description: 'Annotate the target namespace'
       required: false
       default: true
+   private-cluster:
+      description: 'True if cluster is AKS private cluster'
+      required: false
+      default: false
+   resource-group:
+      description: 'Name of resource group - Only required if using private cluster'
+      required: false
+   name:
+      description: 'Resource group name - Only required if using private cluster'
+      required: false
 
 branding:
    color: 'green'

package.json

@@ -23,9 +23,8 @@
       "@types/jest": "^26.0.0",
       "@types/js-yaml": "^3.12.7",
       "@types/node": "^12.20.41",
-      "@vercel/ncc": "^0.34.0",
       "jest": "^26.0.0",
-      "prettier": "2.7.1",
+      "prettier": "^2.7.1",
       "ts-jest": "^26.0.0",
       "typescript": "3.9.5"
    }

src/run.ts

@@ -6,6 +6,7 @@ import {reject} from './actions/reject'
 import {Action, parseAction} from './types/action'
 import {parseDeploymentStrategy} from './types/deploymentStrategy'
 import {getFilesFromDirectories} from './utilities/fileUtils'
+import {PrivateKubectl} from './types/privatekubectl'
 import {parseAnnotations} from './types/annotations'
 
 export async function run() {
@@ -30,10 +31,22 @@ export async function run() {
       .filter((manifest) => manifest.length > 0) // remove any blanks
 
    const fullManifestFilePaths = getFilesFromDirectories(manifestFilePaths)
-   // create kubectl
    const kubectlPath = await getKubectlPath()
    const namespace = core.getInput('namespace') || 'default'
-   const kubectl = new Kubectl(kubectlPath, namespace, true)
+   const isPrivateCluster =
+      core.getInput('private-cluster').toLowerCase() === 'true'
+   const resourceGroup = core.getInput('resource-group') || ''
+   const resourceName = core.getInput('name') || ''
+
+   const kubectl = isPrivateCluster
+      ? new PrivateKubectl(
+           kubectlPath,
+           namespace,
+           true,
+           resourceGroup,
+           resourceName
+        )
+      : new Kubectl(kubectlPath, namespace, true)
 
    // run action
    switch (action) {

src/strategyHelpers/blueGreen/blueGreenHelper.test.ts

@@ -0,0 +1,128 @@
+import {
+   createWorkloadsWithLabel,
+   deleteWorkloadsAndServicesWithLabel,
+   getManifestObjects,
+   getNewBlueGreenObject,
+   GREEN_LABEL_VALUE,
+   isServiceRouted,
+   NONE_LABEL_VALUE
+} from './blueGreenHelper'
+import * as bgHelper from './blueGreenHelper'
+import {Kubectl} from '../../types/kubectl'
+import * as fileHelper from '../../utilities/fileUtils'
+
+jest.mock('../../types/kubectl')
+
+describe('bluegreenhelper functions', () => {
+   let testObjects
+   beforeEach(() => {
+      //@ts-ignore
+      Kubectl.mockClear()
+      testObjects = getManifestObjects(['test/unit/manifests/test-ingress.yml'])
+
+      jest
+         .spyOn(fileHelper, 'writeObjectsToFile')
+         .mockImplementationOnce(() => [''])
+   })
+
+   test('it should parse objects correctly from one file', () => {
+      expect(testObjects.deploymentEntityList[0].kind).toBe('Deployment')
+      expect(testObjects.serviceEntityList[0].kind).toBe('Service')
+      expect(testObjects.ingressEntityList[0].kind).toBe('Ingress')
+
+      expect(
+         testObjects.deploymentEntityList[0].spec.selector.matchLabels.app
+      ).toBe('nginx')
+   })
+
+   test('correctly makes new blue green object', () => {
+      const modifiedDeployment = getNewBlueGreenObject(
+         testObjects.deploymentEntityList[0],
+         GREEN_LABEL_VALUE
+      )
+      //@ts-ignore
+      expect(modifiedDeployment.metadata.name).toBe('nginx-deployment-green')
+      //@ts-ignore
+      expect(modifiedDeployment.metadata.labels['k8s.deploy.color']).toBe(
+         'green'
+      )
+
+      const modifiedSvc = getNewBlueGreenObject(
+         testObjects.serviceEntityList[0],
+         GREEN_LABEL_VALUE
+      )
+      //@ts-ignore
+      expect(modifiedSvc.metadata.name).toBe('nginx-service-green')
+      //@ts-ignore
+      expect(modifiedSvc.metadata.labels['k8s.deploy.color']).toBe('green')
+   })
+
+   test('correctly makes labeled workloads', () => {
+      const kubectl = new Kubectl('')
+      expect(Kubectl).toBeCalledTimes(1)
+      const cwlResult = createWorkloadsWithLabel(
+         kubectl,
+         testObjects.deploymentEntityList,
+         GREEN_LABEL_VALUE
+      )
+      cwlResult.then((value) => {
+         //@ts-ignore
+         expect(value.newFilePaths[0]).toBe('')
+      })
+   })
+
+   test('correctly classifies routed services', () => {
+      expect(
+         isServiceRouted(
+            testObjects.serviceEntityList[0],
+            testObjects.deploymentEntityList
+         )
+      ).toBe(true)
+      testObjects.serviceEntityList[0].spec.selector.app = 'fakeapp'
+      expect(
+         isServiceRouted(
+            testObjects.serviceEntityList[0],
+            testObjects.deploymentEntityList
+         )
+      ).toBe(false)
+   })
+
+   test('correctly deletes services and workloads according to label', () => {
+      const kubectl = new Kubectl('')
+      jest.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
+
+      let objectsToDelete = deleteWorkloadsAndServicesWithLabel(
+         kubectl,
+         NONE_LABEL_VALUE,
+         testObjects.deploymentEntityList,
+         testObjects.serviceEntityList
+      )
+      objectsToDelete.then((value) => {
+         expect(value).toHaveLength(2)
+         expect(value).toContainEqual
+         ;({name: 'nginx-service', kind: 'Service'})
+         expect(value).toContainEqual({
+            name: 'nginx-deployment',
+            kind: 'Deployment'
+         })
+      })
+
+      objectsToDelete = deleteWorkloadsAndServicesWithLabel(
+         kubectl,
+         GREEN_LABEL_VALUE,
+         testObjects.deploymentEntityList,
+         testObjects.serviceEntityList
+      )
+      objectsToDelete.then((value) => {
+         expect(value).toHaveLength(2)
+         expect(value).toContainEqual({
+            name: 'nginx-service-green',
+            kind: 'Service'
+         })
+         expect(value).toContainEqual({
+            name: 'nginx-deployment-green',
+            kind: 'Deployment'
+         })
+      })
+   })
+})

src/strategyHelpers/blueGreen/blueGreenHelper.ts

@@ -112,6 +112,7 @@ export async function deleteWorkloadsWithLabel(
    })
 
    await deleteObjects(kubectl, resourcesToDelete)
+   return resourcesToDelete
 }
 
 export async function deleteWorkloadsAndServicesWithLabel(
@@ -143,6 +144,7 @@ export async function deleteWorkloadsAndServicesWithLabel(
    })
 
    await deleteObjects(kubectl, resourcesToDelete)
+   return resourcesToDelete
 }
 
 export async function deleteObjects(kubectl: Kubectl, deleteList: any[]) {
@@ -237,9 +239,6 @@ export async function createWorkloadsWithLabel(
    deploymentObjectList.forEach((inputObject) => {
       // creating deployment with label
       const newBlueGreenObject = getNewBlueGreenObject(inputObject, nextLabel)
-      core.debug(
-         'New blue-green object is: ' + JSON.stringify(newBlueGreenObject)
-      )
       newObjectsList.push(newBlueGreenObject)
    })
 
@@ -280,7 +279,7 @@ export function addBlueGreenLabelsAndAnnotations(
    updateObjectLabels(inputObject, newLabels, false)
    updateSelectorLabels(inputObject, newLabels, false)
 
-   // updating spec labels if it is a service
+   // updating spec labels if it is not a service
    if (!isServiceEntity(inputObject.kind)) {
       updateSpecLabels(inputObject, newLabels, false)
    }

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.test.ts

@@ -0,0 +1,88 @@
+import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper'
+import {
+   deployBlueGreenIngress,
+   getUpdatedBlueGreenIngress,
+   isIngressRouted,
+   routeBlueGreenIngress
+} from './ingressBlueGreenHelper'
+import {Kubectl} from '../../types/kubectl'
+import * as fileHelper from '../../utilities/fileUtils'
+
+jest.mock('../../types/kubectl')
+
+describe('ingress blue green helpers', () => {
+   let testObjects
+   const betaFilepath = ['test/unit/manifests/test-ingress.yml']
+   const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
+
+   beforeEach(() => {
+      //@ts-ignore
+      Kubectl.mockClear()
+      testObjects = getManifestObjects(ingressFilepath)
+      jest
+         .spyOn(fileHelper, 'writeObjectsToFile')
+         .mockImplementationOnce(() => [''])
+   })
+
+   test('it should correctly classify ingresses', () => {
+      expect(
+         isIngressRouted(
+            testObjects.ingressEntityList[0],
+            testObjects.serviceNameMap
+         )
+      ).toBe(true)
+      testObjects.ingressEntityList[0].spec.rules[0].http.paths = {}
+      expect(
+         isIngressRouted(
+            testObjects.ingressEntityList[0],
+            testObjects.serviceNameMap
+         )
+      ).toBe(false)
+
+      expect(
+         isIngressRouted(
+            getManifestObjects(betaFilepath).ingressEntityList[0],
+            testObjects.serviceNameMap
+         )
+      ).toBe(true)
+   })
+
+   test('it should correctly update ingresses', () => {
+      const updatedIng = getUpdatedBlueGreenIngress(
+         testObjects.ingressEntityList[0],
+         testObjects.serviceNameMap,
+         GREEN_LABEL_VALUE
+      )
+      //@ts-ignore
+      expect(updatedIng.metadata.labels['k8s.deploy.color']).toBe('green')
+      //@ts-ignore
+      expect(updatedIng.spec.rules[0].http.paths[0].backend.service.name).toBe(
+         'nginx-service-green'
+      )
+   })
+
+   test('correctly prepares blue/green ingresses for deployment', () => {
+      const kc = new Kubectl('')
+      const generatedObjects = routeBlueGreenIngress(
+         kc,
+         GREEN_LABEL_VALUE,
+         testObjects.serviceNameMap,
+         testObjects.ingressEntityList
+      )
+      generatedObjects.then((value) => {
+         expect(value).toHaveLength(1)
+         //@ts-ignore
+         expect(value[0].metadata.name).toBe('nginx-ingress')
+      })
+   })
+   test('correctly deploys services', () => {
+      const kc = new Kubectl('')
+      const result = deployBlueGreenIngress(kc, ingressFilepath)
+
+      result.then((value) => {
+         const nol = value.newObjectsList
+         //@ts-ignore
+         expect(nol[0].metadata.name).toBe('nginx-service-green')
+      })
+   })
+})

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.ts

@@ -14,7 +14,7 @@ import {
 } from './blueGreenHelper'
 import * as core from '@actions/core'
 
-const BACKEND = 'BACKEND'
+const BACKEND = 'backend'
 
 export async function deployBlueGreenIngress(
    kubectl: Kubectl,
@@ -24,13 +24,12 @@ export async function deployBlueGreenIngress(
    const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
 
    // create deployments with green label value
-   const result = createWorkloadsWithLabel(
+   const workloadDeployment = await createWorkloadsWithLabel(
       kubectl,
       manifestObjects.deploymentEntityList,
       GREEN_LABEL_VALUE
    )
 
-   // create new services and other objects
    let newObjectsList = []
    manifestObjects.serviceEntityList.forEach((inputObject) => {
       const newBlueGreenObject = getNewBlueGreenObject(
@@ -46,7 +45,12 @@ export async function deployBlueGreenIngress(
    const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
    await kubectl.apply(manifestFiles)
 
-   return result
+   core.debug(
+      'new objects after processing services and other objects: \n' +
+         JSON.stringify(newObjectsList)
+   )
+
+   return {workloadDeployment, newObjectsList}
 }
 
 export async function promoteBlueGreenIngress(
@@ -54,14 +58,13 @@ export async function promoteBlueGreenIngress(
    manifestObjects
 ) {
    //checking if anything to promote
-   if (
+   const {areValid, invalidIngresses} = validateIngresses(
-      !validateIngressesState(
+      kubectl,
-         kubectl,
+      manifestObjects.ingressEntityList,
-         manifestObjects.ingressEntityList,
+      manifestObjects.serviceNameMap
-         manifestObjects.serviceNameMap
+   )
-      )
+   if (!areValid) {
-   ) {
+      throw 'Ingresses are not in promote state' + invalidIngresses.toString()
-      throw 'Ingress not in promote state'
    }
 
    // create stable deployments with new configuration
@@ -138,17 +141,18 @@ export async function routeBlueGreenIngress(
       })
    }
 
-   core.debug('New objects: ' + JSON.stringify(newObjectsList))
    const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
    await kubectl.apply(manifestFiles)
+   return newObjectsList
 }
 
-export function validateIngressesState(
+export function validateIngresses(
    kubectl: Kubectl,
    ingressEntityList: any[],
    serviceNameMap: Map<string, string>
-): boolean {
+): {areValid: boolean; invalidIngresses: string[]} {
-   let areIngressesTargetingNewServices: boolean = true
+   let areValid: boolean = true
+   const invalidIngresses = []
    ingressEntityList.forEach(async (inputObject) => {
       if (isIngressRouted(inputObject, serviceNameMap)) {
          //querying existing ingress
@@ -158,33 +162,32 @@ export function validateIngressesState(
             inputObject.metadata.name
          )
 
-         if (!!existingIngress) {
+         let isValid =
-            const currentLabel: string =
+            !!existingIngress &&
-               existingIngress?.metadata?.labels[BLUE_GREEN_VERSION_LABEL]
+            existingIngress?.metadata?.labels[BLUE_GREEN_VERSION_LABEL] ===
-
+               GREEN_LABEL_VALUE
-            // if not green label, then wrong configuration
+         if (!isValid) {
-            if (currentLabel != GREEN_LABEL_VALUE)
+            invalidIngresses.push(inputObject.metadata.name)
-               areIngressesTargetingNewServices = false
-         } else {
-            // no ingress at all, so nothing to promote
-            areIngressesTargetingNewServices = false
          }
+         // to be valid, ingress should exist and should be green
+         areValid = areValid && isValid
       }
    })
 
-   return areIngressesTargetingNewServices
+   return {areValid, invalidIngresses}
 }
 
-function isIngressRouted(
+export function isIngressRouted(
    ingressObject: any,
    serviceNameMap: Map<string, string>
 ): boolean {
    let isIngressRouted: boolean = false
    // check if ingress targets a service in the given manifests
    JSON.parse(JSON.stringify(ingressObject), (key, value) => {
-      if (key === 'serviceName' && serviceNameMap.has(value)) {
+      isIngressRouted =
-         isIngressRouted = true
+         isIngressRouted || (key === 'service' && value.hasOwnProperty('name'))
-      }
+      isIngressRouted =
+         isIngressRouted || (key === 'serviceName' && serviceNameMap.has(value))
 
       return value
    })
@@ -206,15 +209,18 @@ export function getUpdatedBlueGreenIngress(
    addBlueGreenLabelsAndAnnotations(newObject, type)
 
    // update ingress labels
+   if (inputObject.apiVersion === 'networking.k8s.io/v1beta1') {
+      return updateIngressBackendBetaV1(newObject, serviceNameMap)
+   }
    return updateIngressBackend(newObject, serviceNameMap)
 }
 
-export function updateIngressBackend(
+export function updateIngressBackendBetaV1(
    inputObject: any,
    serviceNameMap: Map<string, string>
 ): any {
    inputObject = JSON.parse(JSON.stringify(inputObject), (key, value) => {
-      if (key.toUpperCase() === BACKEND) {
+      if (key.toLowerCase() === BACKEND) {
          const {serviceName} = value
          if (serviceNameMap.has(serviceName)) {
             // update service name with corresponding bluegreen name only if service is provied in given manifests
@@ -227,3 +233,20 @@ export function updateIngressBackend(
 
    return inputObject
 }
+
+export function updateIngressBackend(
+   inputObject: any,
+   serviceNameMap: Map<string, string>
+): any {
+   inputObject = JSON.parse(JSON.stringify(inputObject), (key, value) => {
+      if (
+         key.toLowerCase() === BACKEND &&
+         serviceNameMap.has(value?.service?.name)
+      ) {
+         value.service.name = serviceNameMap.get(value.service.name)
+      }
+      return value
+   })
+
+   return inputObject
+}

src/strategyHelpers/blueGreen/serviceBlueGreenHelper.ts

@@ -19,21 +19,21 @@ export async function deployBlueGreenService(
    const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
 
    // create deployments with green label value
-   const result = await createWorkloadsWithLabel(
+   const workloadDeployment = await createWorkloadsWithLabel(
       kubectl,
       manifestObjects.deploymentEntityList,
       GREEN_LABEL_VALUE
    )
 
-   // create other non deployment and non service entities
    const newObjectsList = manifestObjects.otherObjects
       .concat(manifestObjects.ingressEntityList)
       .concat(manifestObjects.unroutedServiceEntityList)
    const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+
    if (manifestFiles.length > 0) await kubectl.apply(manifestFiles)
 
    // returning deployment details to check for rollout stability
-   return result
+   return {workloadDeployment, newObjectsList}
 }
 
 export async function promoteBlueGreenService(
@@ -76,7 +76,6 @@ export async function rejectBlueGreenService(
       manifestObjects.deploymentEntityList
    )
 }
-
 export async function routeBlueGreenService(
    kubectl: Kubectl,
    nextLabel: string,

src/strategyHelpers/blueGreen/smiBlueGreenHelper.ts

@@ -41,11 +41,13 @@ export async function deployBlueGreenSMI(
    await setupSMI(kubectl, manifestObjects.serviceEntityList, annotations)
 
    // create new deloyments
-   return await createWorkloadsWithLabel(
+   const workloadDeployment = await createWorkloadsWithLabel(
       kubectl,
       manifestObjects.deploymentEntityList,
       GREEN_LABEL_VALUE
    )
+
+   return {workloadDeployment, newObjectsList}
 }
 
 export async function promoteBlueGreenSMI(kubectl: Kubectl, manifestObjects) {

src/strategyHelpers/deploymentHelper.ts

@@ -60,7 +60,7 @@ export async function deployManifests(
             core.getInput('route-method', {required: true})
          )
 
-         const {result, newFilePaths} = await Promise.resolve(
+         const {workloadDeployment, newObjectsList} = await Promise.resolve(
             (routeStrategy == RouteStrategy.INGRESS &&
                deployBlueGreenIngress(kubectl, files)) ||
                (routeStrategy == RouteStrategy.SMI &&
@@ -68,8 +68,8 @@ export async function deployManifests(
                deployBlueGreenService(kubectl, files)
          )
 
-         checkForErrors([result])
+         checkForErrors([workloadDeployment.result])
-         return newFilePaths
+         return workloadDeployment.newFilePaths
       }
 
       case DeploymentStrategy.BASIC: {
@@ -143,7 +143,7 @@ export async function annotateAndLabelResources(
    const workflowFilePath = await getWorkflowFilePath(githubToken)
 
    const deploymentConfig = await getDeploymentConfig()
-   const annotationKeyLabel = getWorkflowAnnotationKeyLabel(workflowFilePath)
+   const annotationKeyLabel = getWorkflowAnnotationKeyLabel()
 
    await annotateResources(
       files,

src/types/kubectl.ts

@@ -10,18 +10,25 @@ export interface Resource {
 }
 
 export class Kubectl {
-   private readonly kubectlPath: string
+   protected readonly kubectlPath: string
-   private readonly namespace: string
+   protected readonly namespace: string
-   private readonly ignoreSSLErrors: boolean
+   protected readonly ignoreSSLErrors: boolean
+   protected readonly resourceGroup: string
+   protected readonly name: string
+   protected isPrivateCluster: boolean
 
    constructor(
       kubectlPath: string,
       namespace: string = 'default',
-      ignoreSSLErrors: boolean = false
+      ignoreSSLErrors: boolean = false,
+      resourceGroup: string = '',
+      name: string = ''
    ) {
       this.kubectlPath = kubectlPath
       this.ignoreSSLErrors = !!ignoreSSLErrors
       this.namespace = namespace
+      this.resourceGroup = resourceGroup
+      this.name = name
    }
 
    public async apply(
@@ -155,7 +162,7 @@ export class Kubectl {
       return this.execute(['delete', ...args])
    }
 
-   private async execute(args: string[], silent: boolean = false) {
+   protected async execute(args: string[], silent: boolean = false) {
       if (this.ignoreSSLErrors) {
          args.push('--insecure-skip-tls-verify')
       }

src/types/privatekubectl.ts

@@ -0,0 +1,135 @@
+import {Kubectl} from './kubectl'
+import {ExecOptions, ExecOutput, getExecOutput} from '@actions/exec'
+import * as core from '@actions/core'
+import * as os from 'os'
+import * as fs from 'fs'
+import * as path from 'path'
+
+export class PrivateKubectl extends Kubectl {
+   protected async execute(args: string[], silent: boolean = false) {
+      args.unshift('kubectl')
+      let kubectlCmd = args.join(' ')
+      let addFileFlag = false
+      let eo = <ExecOptions>{silent}
+
+      if (this.containsFilenames(kubectlCmd)) {
+         // For private clusters, files will referenced solely by their basename
+         kubectlCmd = this.replaceFilnamesWithBasenames(kubectlCmd)
+         addFileFlag = true
+      }
+
+      const privateClusterArgs = [
+         'aks',
+         'command',
+         'invoke',
+         '--resource-group',
+         this.resourceGroup,
+         '--name',
+         this.name,
+         '--command',
+         kubectlCmd
+      ]
+
+      if (addFileFlag) {
+         const filenames = this.extractFilesnames(kubectlCmd).split(' ')
+
+         const tempDirectory =
+            process.env['runner.tempDirectory'] || os.tmpdir() + '/manifests'
+         eo.cwd = tempDirectory
+         privateClusterArgs.push(...['--file', '.'])
+
+         let filenamesArr = filenames[0].split(',')
+         for (let index = 0; index < filenamesArr.length; index++) {
+            const file = filenamesArr[index]
+
+            if (!file) {
+               continue
+            }
+            this.moveFileToTempManifestDir(file)
+         }
+      }
+
+      core.debug(
+         `private cluster Kubectl run with invoke command: ${kubectlCmd}`
+      )
+      return await getExecOutput('az', privateClusterArgs, eo)
+   }
+
+   private replaceFilnamesWithBasenames(kubectlCmd: string) {
+      let exFilenames = this.extractFilesnames(kubectlCmd)
+      let filenames = exFilenames.split(' ')
+      let filenamesArr = filenames[0].split(',')
+
+      for (let index = 0; index < filenamesArr.length; index++) {
+         filenamesArr[index] = path.basename(filenamesArr[index])
+      }
+
+      let baseFilenames = filenamesArr.join()
+
+      let result = kubectlCmd.replace(exFilenames, baseFilenames)
+      return result
+   }
+
+   public extractFilesnames(strToParse: string) {
+      let start = strToParse.indexOf('-filename')
+      let offset = 7
+
+      if (start == -1) {
+         start = strToParse.indexOf('-f')
+
+         if (start == -1) {
+            return ''
+         }
+         offset = 0
+      }
+
+      let temp = strToParse.substring(start + offset)
+      let end = temp.indexOf(' -')
+
+      //End could be case where the -f flag was last, or -f is followed by some additonal flag and it's arguments
+      return temp.substring(3, end == -1 ? temp.length : end).trim()
+   }
+
+   private containsFilenames(str: string) {
+      return str.includes('-f ') || str.includes('filename ')
+   }
+
+   private createTempManifestsDirectory() {
+      const manifestsDir = '/tmp/manifests'
+      if (!fs.existsSync('/tmp/manifests')) {
+         fs.mkdirSync('/tmp/manifests', {recursive: true})
+      }
+   }
+
+   private moveFileToTempManifestDir(file: string) {
+      this.createTempManifestsDirectory()
+      if (!fs.existsSync('/tmp/' + file)) {
+         core.debug(
+            '/tmp/' +
+               file +
+               ' does not exist, and therefore cannot be moved to the manifest directory'
+         )
+      }
+
+      fs.copyFile('/tmp/' + file, '/tmp/manifests/' + file, function (err) {
+         if (err) {
+            core.debug(
+               'Could not rename ' +
+                  '/tmp/' +
+                  file +
+                  ' to  ' +
+                  '/tmp/manifests/' +
+                  file +
+                  ' ERROR: ' +
+                  err
+            )
+            return
+         }
+         core.debug(
+            "Successfully moved file '" +
+               file +
+               "' from /tmp to /tmp/manifest directory"
+         )
+      })
+   }
+}

src/utilities/fileUtils.test.ts

@@ -12,11 +12,12 @@ describe('File utils', () => {
          'test/unit/manifests/manifest_test_dir/another_layer/deep-service.yaml',
          'test/unit/manifests/manifest_test_dir/nested-test-service.yaml',
          'test/unit/manifests/test-ingress.yml',
+         'test/unit/manifests/test-ingress-new.yml',
          'test/unit/manifests/test-service.yml'
       ]
 
       // is there a more efficient way to test equality w random order?
-      expect(testSearch).toHaveLength(5)
+      expect(testSearch).toHaveLength(6)
       expectedManifests.forEach((fileName) => {
          expect(testSearch).toContain(fileName)
       })
@@ -53,7 +54,7 @@ describe('File utils', () => {
 
       expect(
          getFilesFromDirectories([outerPath, fileAtOuter, innerPath])
-      ).toHaveLength(5)
+      ).toHaveLength(6)
    })
 })
 

src/utilities/fileUtils.ts

@@ -57,7 +57,7 @@ export function writeManifestToFile(
 }
 
 function getManifestFileName(kind: string, name: string) {
-   const filePath = `${kind}_${name}_ ${getCurrentTime().toString()}`
+   const filePath = `${kind}_${name}_${getCurrentTime().toString()}`
    const tempDirectory = getTempDirectory()
    return path.join(tempDirectory, path.basename(filePath))
 }

src/utilities/workflowAnnotationUtils.test.ts

@@ -1,24 +1,6 @@
-import {
+import {cleanLabel} from '../utilities/workflowAnnotationUtils'
-   cleanLabel,
-   prefixObjectKeys
-} from '../utilities/workflowAnnotationUtils'
 
 describe('WorkflowAnnotationUtils', () => {
-   describe('prefixObjectKeys', () => {
-      it('should prefix an object with a given prefix', () => {
-         const obj = {
-            foo: 'bar',
-            baz: 'qux'
-         }
-         const prefix = 'prefix.'
-         const expected = {
-            'prefix.foo': 'bar',
-            'prefix.baz': 'qux'
-         }
-         expect(prefixObjectKeys(obj, prefix)).toEqual(expected)
-      })
-   })
-
    describe('cleanLabel', () => {
       it('should clean label', () => {
          const alreadyClean = 'alreadyClean'

src/utilities/workflowAnnotationUtils.ts

@@ -1,13 +1,6 @@
 import {DeploymentConfig} from '../types/deploymentConfig'
 
-const ANNOTATION_PREFIX = 'actions.github.com/'
+const ANNOTATION_PREFIX = 'actions.github.com'
-
-export function prefixObjectKeys(obj: any, prefix: string): any {
-   return Object.keys(obj).reduce((newObj, key) => {
-      newObj[prefix + key] = obj[key]
-      return newObj
-   }, {})
-}
 
 export function getWorkflowAnnotations(
    lastSuccessRunSha: string,
@@ -31,21 +24,11 @@ export function getWorkflowAnnotations(
       helmChartPaths: deploymentConfig.helmChartFilePaths,
       provider: 'GitHub'
    }
-   const prefixedAnnotationObject = prefixObjectKeys(
+   return JSON.stringify(annotationObject)
-      annotationObject,
-      ANNOTATION_PREFIX
-   )
-   return JSON.stringify(prefixedAnnotationObject)
 }
 
-export function getWorkflowAnnotationKeyLabel(
+export function getWorkflowAnnotationKeyLabel(): string {
-   workflowFilePath: string
+   return `${ANNOTATION_PREFIX}/k8s-deploy`
-): string {
-   const hashKey = require('crypto')
-      .createHash('MD5')
-      .update(`${process.env.GITHUB_REPOSITORY}/${workflowFilePath}`)
-      .digest('hex')
-   return `githubWorkflow_${hashKey}`
 }
 
 /**

test/unit/manifests/test-ingress-new.yml

@@ -0,0 +1,50 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+   name: nginx-deployment
+   labels:
+      app: nginx
+spec:
+   replicas: 1
+   selector:
+      matchLabels:
+         app: nginx
+   template:
+      metadata:
+         labels:
+            app: nginx
+      spec:
+         containers:
+            - name: nginx
+              image: nginx:1.14.2
+              ports:
+                 - containerPort: 80
+---
+apiVersion: v1
+kind: Service
+metadata:
+   name: nginx-service
+spec:
+   selector:
+      app: nginx
+   ports:
+      - protocol: TCP
+        port: 80
+        targetPort: 80
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+   name: nginx-ingress
+   annotations:
+      nginx.ingress.kubernetes.io/rewrite-target: /
+spec:
+   rules:
+      - http:
+           paths:
+              - path: /testpath
+                backend:
+                   service:
+                      name: nginx-service
+                      port:
+                         number: 80