Cloud Runner v2 (#310)

2026-02-04 08:09:08 +08:00 · 2022-02-01 02:31:20 +00:00
parent 4e38a84fe7
commit 03ae77dc7c
90 changed files with 162797 additions and 97684 deletions
--- a/src/model/cloud-runner/aws/aws-base-stack.ts
+++ b/src/model/cloud-runner/aws/aws-base-stack.ts
@@ -0,0 +1,106 @@
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import * as core from '@actions/core';
+import * as SDK from 'aws-sdk';
+import * as fs from 'fs';
+import path from 'path';
+const crypto = require('crypto');
+
+export class AWSBaseStack {
+  constructor(baseStackName: string) {
+    this.baseStackName = baseStackName;
+  }
+  private baseStackName: string;
+
+  async setupBaseStack(CF: SDK.CloudFormation) {
+    const baseStackName = this.baseStackName;
+
+    const baseStack = fs.readFileSync(path.join(__dirname, 'cloud-formations', 'base-setup.yml'), 'utf8');
+
+    // Cloud Formation Input
+    const describeStackInput: SDK.CloudFormation.DescribeStacksInput = {
+      StackName: baseStackName,
+    };
+    const parametersWithoutHash: SDK.CloudFormation.Parameter[] = [
+      { ParameterKey: 'EnvironmentName', ParameterValue: baseStackName },
+    ];
+    const parametersHash = crypto
+      .createHash('md5')
+      .update(baseStack + JSON.stringify(parametersWithoutHash))
+      .digest('hex');
+    const parameters: SDK.CloudFormation.Parameter[] = [
+      ...parametersWithoutHash,
+      ...[{ ParameterKey: 'Version', ParameterValue: parametersHash }],
+    ];
+    const updateInput: SDK.CloudFormation.UpdateStackInput = {
+      StackName: baseStackName,
+      TemplateBody: baseStack,
+      Parameters: parameters,
+      Capabilities: ['CAPABILITY_IAM'],
+    };
+    const createStackInput: SDK.CloudFormation.CreateStackInput = {
+      StackName: baseStackName,
+      TemplateBody: baseStack,
+      Parameters: parameters,
+      Capabilities: ['CAPABILITY_IAM'],
+    };
+
+    const stacks = await CF.listStacks({
+      StackStatusFilter: ['UPDATE_COMPLETE', 'CREATE_COMPLETE', 'ROLLBACK_COMPLETE'],
+    }).promise();
+    const stackNames = stacks.StackSummaries?.map((x) => x.StackName) || [];
+    const stackExists: Boolean = stackNames.includes(baseStackName) || false;
+    const describeStack = async () => {
+      return await CF.describeStacks(describeStackInput).promise();
+    };
+    try {
+      if (!stackExists) {
+        CloudRunnerLogger.log(`${baseStackName} stack does not exist (${JSON.stringify(stackNames)})`);
+        await CF.createStack(createStackInput).promise();
+        CloudRunnerLogger.log(`created stack (version: ${parametersHash})`);
+      }
+      const CFState = await describeStack();
+      let stack = CFState.Stacks?.[0];
+      if (!stack) {
+        throw new Error(`Base stack doesn't exist, even after creation, stackExists check: ${stackExists}`);
+      }
+      const stackVersion = stack.Parameters?.find((x) => x.ParameterKey === 'Version')?.ParameterValue;
+
+      if (stack.StackStatus === 'CREATE_IN_PROGRESS') {
+        await CF.waitFor('stackCreateComplete', describeStackInput).promise();
+      }
+
+      if (stackExists) {
+        CloudRunnerLogger.log(`Base stack exists (version: ${stackVersion}, local version: ${parametersHash})`);
+        if (parametersHash !== stackVersion) {
+          CloudRunnerLogger.log(`Attempting update of base stack`);
+          try {
+            await CF.updateStack(updateInput).promise();
+          } catch (error: any) {
+            if (error['message'].includes('No updates are to be performed')) {
+              CloudRunnerLogger.log(`No updates are to be performed`);
+            } else {
+              CloudRunnerLogger.log(`Update Failed (Stack name: ${baseStackName})`);
+              CloudRunnerLogger.log(error['message']);
+            }
+            CloudRunnerLogger.log(`Continuing...`);
+          }
+        } else {
+          CloudRunnerLogger.log(`No update required`);
+        }
+        stack = (await describeStack()).Stacks?.[0];
+        if (!stack) {
+          throw new Error(
+            `Base stack doesn't exist, even after updating and creation, stackExists check: ${stackExists}`,
+          );
+        }
+        if (stack.StackStatus === 'UPDATE_IN_PROGRESS') {
+          await CF.waitFor('stackUpdateComplete', describeStackInput).promise();
+        }
+      }
+      CloudRunnerLogger.log('base stack is now ready');
+    } catch (error) {
+      core.error(JSON.stringify(await describeStack(), undefined, 4));
+      throw error;
+    }
+  }
+}
--- a/src/model/cloud-runner/aws/aws-error.ts
+++ b/src/model/cloud-runner/aws/aws-error.ts
@@ -0,0 +1,16 @@
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import * as SDK from 'aws-sdk';
+import * as core from '@actions/core';
+import { Input } from '../..';
+
+export class AWSError {
+  static async handleStackCreationFailure(error: any, CF: SDK.CloudFormation, taskDefStackName: string) {
+    CloudRunnerLogger.log('aws error: ');
+    core.error(JSON.stringify(error, undefined, 4));
+    if (Input.cloudRunnerTests) {
+      CloudRunnerLogger.log('Getting events and resources for task stack');
+      const events = (await CF.describeStackEvents({ StackName: taskDefStackName }).promise()).StackEvents;
+      CloudRunnerLogger.log(JSON.stringify(events, undefined, 4));
+    }
+  }
+}
--- a/src/model/cloud-runner/aws/aws-job-stack.ts
+++ b/src/model/cloud-runner/aws/aws-job-stack.ts
@@ -0,0 +1,141 @@
+import * as SDK from 'aws-sdk';
+import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import { AWSTemplates } from './aws-templates';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { AWSError } from './aws-error';
+
+export class AWSJobStack {
+  private baseStackName: string;
+  constructor(baseStackName: string) {
+    this.baseStackName = baseStackName;
+  }
+
+  public async setupCloudFormations(
+    CF: SDK.CloudFormation,
+    buildGuid: string,
+    image: string,
+    entrypoint: string[],
+    commands: string,
+    mountdir: string,
+    workingdir: string,
+    secrets: CloudRunnerSecret[],
+  ): Promise<CloudRunnerAWSTaskDef> {
+    const taskDefStackName = `${this.baseStackName}-${buildGuid}`;
+    let taskDefCloudFormation = AWSTemplates.readTaskCloudFormationTemplate();
+    for (const secret of secrets) {
+      secret.ParameterKey = `${buildGuid.replace(/[^\dA-Za-z]/g, '')}${secret.ParameterKey.replace(
+        /[^\dA-Za-z]/g,
+        '',
+      )}`;
+      if (typeof secret.ParameterValue == 'number') {
+        secret.ParameterValue = `${secret.ParameterValue}`;
+      }
+      if (!secret.ParameterValue || secret.ParameterValue === '') {
+        secrets = secrets.filter((x) => x !== secret);
+        continue;
+      }
+      taskDefCloudFormation = AWSTemplates.insertAtTemplate(
+        taskDefCloudFormation,
+        'p1 - input',
+        AWSTemplates.getParameterTemplate(secret.ParameterKey),
+      );
+      taskDefCloudFormation = AWSTemplates.insertAtTemplate(
+        taskDefCloudFormation,
+        'p2 - secret',
+        AWSTemplates.getSecretTemplate(`${secret.ParameterKey}`),
+      );
+      taskDefCloudFormation = AWSTemplates.insertAtTemplate(
+        taskDefCloudFormation,
+        'p3 - container def',
+        AWSTemplates.getSecretDefinitionTemplate(secret.EnvironmentVariable, secret.ParameterKey),
+      );
+    }
+    const secretsMappedToCloudFormationParameters = secrets.map((x) => {
+      return { ParameterKey: x.ParameterKey.replace(/[^\dA-Za-z]/g, ''), ParameterValue: x.ParameterValue };
+    });
+    const parameters = [
+      {
+        ParameterKey: 'EnvironmentName',
+        ParameterValue: this.baseStackName,
+      },
+      {
+        ParameterKey: 'ImageUrl',
+        ParameterValue: image,
+      },
+      {
+        ParameterKey: 'ServiceName',
+        ParameterValue: taskDefStackName,
+      },
+      {
+        ParameterKey: 'Command',
+        ParameterValue: 'echo "this template should be overwritten when running a task"',
+      },
+      {
+        ParameterKey: 'EntryPoint',
+        ParameterValue: entrypoint.join(','),
+      },
+      {
+        ParameterKey: 'WorkingDirectory',
+        ParameterValue: workingdir,
+      },
+      {
+        ParameterKey: 'EFSMountDirectory',
+        ParameterValue: mountdir,
+      },
+      ...secretsMappedToCloudFormationParameters,
+    ];
+
+    let previousStackExists = true;
+    while (previousStackExists) {
+      previousStackExists = false;
+      const stacks = await CF.listStacks().promise();
+      if (!stacks.StackSummaries) {
+        throw new Error('Faild to get stacks');
+      }
+      for (let index = 0; index < stacks.StackSummaries.length; index++) {
+        const element = stacks.StackSummaries[index];
+        if (element.StackName === taskDefStackName && element.StackStatus !== 'DELETE_COMPLETE') {
+          previousStackExists = true;
+          CloudRunnerLogger.log(`Previous stack still exists: ${JSON.stringify(element)}`);
+        }
+      }
+    }
+
+    try {
+      await CF.createStack({
+        StackName: taskDefStackName,
+        TemplateBody: taskDefCloudFormation,
+        Capabilities: ['CAPABILITY_IAM'],
+        Parameters: parameters,
+      }).promise();
+      CloudRunnerLogger.log('Creating cloud runner job');
+      await CF.waitFor('stackCreateComplete', { StackName: taskDefStackName }).promise();
+    } catch (error) {
+      await AWSError.handleStackCreationFailure(
+        error,
+        CF,
+        taskDefStackName,
+        //taskDefCloudFormation,
+        //parameters,
+        //secrets,
+      );
+      throw error;
+    }
+
+    const taskDefResources = (
+      await CF.describeStackResources({
+        StackName: taskDefStackName,
+      }).promise()
+    ).StackResources;
+
+    const baseResources = (await CF.describeStackResources({ StackName: this.baseStackName }).promise()).StackResources;
+
+    return {
+      taskDefStackName,
+      taskDefCloudFormation,
+      taskDefResources,
+      baseResources,
+    };
+  }
+}
--- a/src/model/cloud-runner/aws/aws-task-runner.ts
+++ b/src/model/cloud-runner/aws/aws-task-runner.ts
@@ -0,0 +1,228 @@
+import * as AWS from 'aws-sdk';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import * as core from '@actions/core';
+import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
+import * as zlib from 'zlib';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { Input } from '../..';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import { CloudRunnerStatics } from '../cloud-runner-statics';
+import { CloudRunnerBuildCommandProcessor } from '../services/cloud-runner-build-command-process';
+
+class AWSTaskRunner {
+  static async runTask(
+    taskDef: CloudRunnerAWSTaskDef,
+    ECS: AWS.ECS,
+    CF: AWS.CloudFormation,
+    environment: CloudRunnerEnvironmentVariable[],
+    buildGuid: string,
+    commands: string,
+  ) {
+    const cluster = taskDef.baseResources?.find((x) => x.LogicalResourceId === 'ECSCluster')?.PhysicalResourceId || '';
+    const taskDefinition =
+      taskDef.taskDefResources?.find((x) => x.LogicalResourceId === 'TaskDefinition')?.PhysicalResourceId || '';
+    const SubnetOne =
+      taskDef.baseResources?.find((x) => x.LogicalResourceId === 'PublicSubnetOne')?.PhysicalResourceId || '';
+    const SubnetTwo =
+      taskDef.baseResources?.find((x) => x.LogicalResourceId === 'PublicSubnetTwo')?.PhysicalResourceId || '';
+    const ContainerSecurityGroup =
+      taskDef.baseResources?.find((x) => x.LogicalResourceId === 'ContainerSecurityGroup')?.PhysicalResourceId || '';
+    const streamName =
+      taskDef.taskDefResources?.find((x) => x.LogicalResourceId === 'KinesisStream')?.PhysicalResourceId || '';
+
+    const task = await ECS.runTask({
+      cluster,
+      taskDefinition,
+      platformVersion: '1.4.0',
+      overrides: {
+        containerOverrides: [
+          {
+            name: taskDef.taskDefStackName,
+            environment,
+            command: ['-c', CloudRunnerBuildCommandProcessor.ProcessCommands(commands, CloudRunnerState.buildParams)],
+          },
+        ],
+      },
+      launchType: 'FARGATE',
+      networkConfiguration: {
+        awsvpcConfiguration: {
+          subnets: [SubnetOne, SubnetTwo],
+          assignPublicIp: 'ENABLED',
+          securityGroups: [ContainerSecurityGroup],
+        },
+      },
+    }).promise();
+
+    CloudRunnerLogger.log('Cloud runner job is starting');
+    const taskArn = task.tasks?.[0].taskArn || '';
+
+    try {
+      await ECS.waitFor('tasksRunning', { tasks: [taskArn], cluster }).promise();
+    } catch (error_) {
+      const error = error_ as Error;
+      await new Promise((resolve) => setTimeout(resolve, 3000));
+      CloudRunnerLogger.log(
+        `Cloud runner job has ended ${
+          (await AWSTaskRunner.describeTasks(ECS, cluster, taskArn)).containers?.[0].lastStatus
+        }`,
+      );
+
+      core.setFailed(error);
+      core.error(error);
+    }
+    CloudRunnerLogger.log(`Cloud runner job is running`);
+
+    const output = await this.streamLogsUntilTaskStops(ECS, CF, taskDef, cluster, taskArn, streamName);
+    const exitCode = (await AWSTaskRunner.describeTasks(ECS, cluster, taskArn)).containers?.[0].exitCode;
+    CloudRunnerLogger.log(`Cloud runner job exit code ${exitCode}`);
+    if (exitCode !== 0 && exitCode !== undefined) {
+      core.error(
+        `job failed with exit code ${exitCode} ${JSON.stringify(
+          await ECS.describeTasks({ tasks: [taskArn], cluster }).promise(),
+          undefined,
+          4,
+        )}`,
+      );
+      throw new Error(`job failed with exit code ${exitCode}`);
+    } else {
+      CloudRunnerLogger.log(`Cloud runner job has finished successfully`);
+      return output;
+    }
+  }
+
+  static async describeTasks(ECS: AWS.ECS, clusterName: string, taskArn: string) {
+    const tasks = await ECS.describeTasks({
+      cluster: clusterName,
+      tasks: [taskArn],
+    }).promise();
+    if (tasks.tasks?.[0]) {
+      return tasks.tasks?.[0];
+    } else {
+      throw new Error('No task found');
+    }
+  }
+
+  static async streamLogsUntilTaskStops(
+    ECS: AWS.ECS,
+    CF: AWS.CloudFormation,
+    taskDef: CloudRunnerAWSTaskDef,
+    clusterName: string,
+    taskArn: string,
+    kinesisStreamName: string,
+  ) {
+    const kinesis = new AWS.Kinesis();
+    const stream = await AWSTaskRunner.getLogStream(kinesis, kinesisStreamName);
+    let iterator = await AWSTaskRunner.getLogIterator(kinesis, stream);
+
+    CloudRunnerLogger.log(
+      `Cloud runner job status is ${(await AWSTaskRunner.describeTasks(ECS, clusterName, taskArn))?.lastStatus}`,
+    );
+
+    const logBaseUrl = `https://${Input.region}.console.aws.amazon.com/cloudwatch/home?region=${CF.config.region}#logsV2:log-groups/log-group/${taskDef.taskDefStackName}`;
+    CloudRunnerLogger.log(`You can also see the logs at AWS Cloud Watch: ${logBaseUrl}`);
+    let shouldReadLogs = true;
+    let timestamp: number = 0;
+    let output = '';
+    while (shouldReadLogs) {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      const taskData = await AWSTaskRunner.describeTasks(ECS, clusterName, taskArn);
+      ({ timestamp, shouldReadLogs } = AWSTaskRunner.checkStreamingShouldContinue(taskData, timestamp, shouldReadLogs));
+      ({ iterator, shouldReadLogs, output } = await AWSTaskRunner.handleLogStreamIteration(
+        kinesis,
+        iterator,
+        shouldReadLogs,
+        taskDef,
+        output,
+      ));
+    }
+    return output;
+  }
+
+  private static async handleLogStreamIteration(
+    kinesis: AWS.Kinesis,
+    iterator: string,
+    shouldReadLogs: boolean,
+    taskDef: CloudRunnerAWSTaskDef,
+    output: string,
+  ) {
+    const records = await kinesis
+      .getRecords({
+        ShardIterator: iterator,
+      })
+      .promise();
+    iterator = records.NextShardIterator || '';
+    ({ shouldReadLogs, output } = AWSTaskRunner.logRecords(records, iterator, taskDef, shouldReadLogs, output));
+    return { iterator, shouldReadLogs, output };
+  }
+
+  private static checkStreamingShouldContinue(taskData: AWS.ECS.Task, timestamp: number, shouldReadLogs: boolean) {
+    if (taskData?.lastStatus !== 'RUNNING') {
+      if (timestamp === 0) {
+        CloudRunnerLogger.log('## Cloud runner job stopped, streaming end of logs');
+        timestamp = Date.now();
+      }
+      if (timestamp !== 0 && Date.now() - timestamp > 30000) {
+        CloudRunnerLogger.log('## Cloud runner status is not RUNNING for 30 seconds, last query for logs');
+        shouldReadLogs = false;
+      }
+      CloudRunnerLogger.log(`## Status of job: ${taskData.lastStatus}`);
+    }
+    return { timestamp, shouldReadLogs };
+  }
+
+  private static logRecords(
+    records,
+    iterator: string,
+    taskDef: CloudRunnerAWSTaskDef,
+    shouldReadLogs: boolean,
+    output: string,
+  ) {
+    if (records.Records.length > 0 && iterator) {
+      for (let index = 0; index < records.Records.length; index++) {
+        const json = JSON.parse(
+          zlib.gunzipSync(Buffer.from(records.Records[index].Data as string, 'base64')).toString('utf8'),
+        );
+        if (json.messageType === 'DATA_MESSAGE') {
+          for (let logEventsIndex = 0; logEventsIndex < json.logEvents.length; logEventsIndex++) {
+            let message = json.logEvents[logEventsIndex].message;
+            if (json.logEvents[logEventsIndex].message.includes(`---${CloudRunnerState.buildParams.logId}`)) {
+              CloudRunnerLogger.log('End of log transmission received');
+              shouldReadLogs = false;
+            } else if (message.includes('Rebuilding Library because the asset database could not be found!')) {
+              core.warning('LIBRARY NOT FOUND!');
+            }
+            message = `[${CloudRunnerStatics.logPrefix}] ${message}`;
+            if (Input.cloudRunnerTests) {
+              output += message;
+            }
+            CloudRunnerLogger.log(message);
+          }
+        }
+      }
+    }
+    return { shouldReadLogs, output };
+  }
+
+  private static async getLogStream(kinesis: AWS.Kinesis, kinesisStreamName: string) {
+    return await kinesis
+      .describeStream({
+        StreamName: kinesisStreamName,
+      })
+      .promise();
+  }
+
+  private static async getLogIterator(kinesis: AWS.Kinesis, stream) {
+    return (
+      (
+        await kinesis
+          .getShardIterator({
+            ShardIteratorType: 'TRIM_HORIZON',
+            StreamName: stream.StreamDescription.StreamName,
+            ShardId: stream.StreamDescription.Shards[0].ShardId,
+          })
+          .promise()
+      ).ShardIterator || ''
+    );
+  }
+}
+export default AWSTaskRunner;
--- a/src/model/cloud-runner/aws/aws-templates.ts
+++ b/src/model/cloud-runner/aws/aws-templates.ts
@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+
+export class AWSTemplates {
+  public static getParameterTemplate(p1) {
+    return `
+  ${p1}:
+    Type: String
+    Default: ''
+`;
+  }
+
+  public static getSecretTemplate(p1) {
+    return `
+  ${p1}Secret:
+    Type: AWS::SecretsManager::Secret
+    Properties:
+      Name: '${p1}'
+      SecretString: !Ref ${p1}
+`;
+  }
+
+  public static getSecretDefinitionTemplate(p1, p2) {
+    return `
+            - Name: '${p1}'
+              ValueFrom: !Ref ${p2}Secret
+`;
+  }
+
+  public static insertAtTemplate(template, insertionKey, insertion) {
+    const index = template.search(insertionKey) + insertionKey.length + '\n'.length;
+    template = [template.slice(0, index), insertion, template.slice(index)].join('');
+    return template;
+  }
+
+  public static readTaskCloudFormationTemplate(): string {
+    return fs.readFileSync(`${__dirname}/cloud-formations/task-def-formation.yml`, 'utf8');
+  }
+}
--- a/src/model/cloud-runner/aws/cloud-formations/base-setup.yml
+++ b/src/model/cloud-runner/aws/cloud-formations/base-setup.yml
@@ -0,0 +1,391 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Description: AWS Fargate cluster that can span public and private subnets. Supports
+  public facing load balancers, private internal load balancers, and
+  both internal and external service discovery namespaces.
+Parameters:
+  EnvironmentName:
+    Type: String
+    Default: development
+    Description: 'Your deployment environment: DEV, QA , PROD'
+  Version:
+    Type: String
+    Description: 'hash of template'
+
+  # ContainerPort:
+  #   Type: Number
+  #   Default: 80
+  #   Description: What port number the application inside the docker container is binding to
+
+Mappings:
+  # Hard values for the subnet masks. These masks define
+  # the range of internal IP addresses that can be assigned.
+  # The VPC can have all IP's from 10.0.0.0 to 10.0.255.255
+  # There are four subnets which cover the ranges:
+  #
+  # 10.0.0.0 - 10.0.0.255
+  # 10.0.1.0 - 10.0.1.255
+  # 10.0.2.0 - 10.0.2.255
+  # 10.0.3.0 - 10.0.3.255
+
+  SubnetConfig:
+    VPC:
+      CIDR: '10.0.0.0/16'
+    PublicOne:
+      CIDR: '10.0.0.0/24'
+    PublicTwo:
+      CIDR: '10.0.1.0/24'
+
+Resources:
+  # VPC in which containers will be networked.
+  # It has two public subnets, and two private subnets.
+  # We distribute the subnets across the first two available subnets
+  # for the region, for high availability.
+  VPC:
+    Type: AWS::EC2::VPC
+    Properties:
+      EnableDnsSupport: true
+      EnableDnsHostnames: true
+      CidrBlock: !FindInMap ['SubnetConfig', 'VPC', 'CIDR']
+
+  EFSServerSecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupName: 'efs-server-endpoints'
+      GroupDescription: Which client ip addrs are allowed to access EFS server
+      VpcId: !Ref 'VPC'
+      SecurityGroupIngress:
+        - IpProtocol: tcp
+          FromPort: 2049
+          ToPort: 2049
+          SourceSecurityGroupId: !Ref ContainerSecurityGroup
+          #CidrIp: !FindInMap ['SubnetConfig', 'VPC', 'CIDR']
+  # A security group for the containers we will run in Fargate.
+  # Rules are added to this security group based on what ingress you
+  # add for the cluster.
+  ContainerSecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupName: 'task security group'
+      GroupDescription: Access to the Fargate containers
+      VpcId: !Ref 'VPC'
+      # SecurityGroupIngress:
+      #   - IpProtocol: tcp
+      #     FromPort: !Ref ContainerPort
+      #     ToPort: !Ref ContainerPort
+      #     CidrIp: 0.0.0.0/0
+      SecurityGroupEgress:
+        - IpProtocol: -1
+          FromPort: 2049
+          ToPort: 2049
+          CidrIp: '0.0.0.0/0'
+
+  # Two public subnets, where containers can have public IP addresses
+  PublicSubnetOne:
+    Type: AWS::EC2::Subnet
+    Properties:
+      AvailabilityZone: !Select
+        - 0
+        - Fn::GetAZs: !Ref 'AWS::Region'
+      VpcId: !Ref 'VPC'
+      CidrBlock: !FindInMap ['SubnetConfig', 'PublicOne', 'CIDR']
+      #  MapPublicIpOnLaunch: true
+
+  PublicSubnetTwo:
+    Type: AWS::EC2::Subnet
+    Properties:
+      AvailabilityZone: !Select
+        - 1
+        - Fn::GetAZs: !Ref 'AWS::Region'
+      VpcId: !Ref 'VPC'
+      CidrBlock: !FindInMap ['SubnetConfig', 'PublicTwo', 'CIDR']
+      #  MapPublicIpOnLaunch: true
+
+  # Setup networking resources for the public subnets. Containers
+  # in the public subnets have public IP addresses and the routing table
+  # sends network traffic via the internet gateway.
+  InternetGateway:
+    Type: AWS::EC2::InternetGateway
+  GatewayAttachement:
+    Type: AWS::EC2::VPCGatewayAttachment
+    Properties:
+      VpcId: !Ref 'VPC'
+      InternetGatewayId: !Ref 'InternetGateway'
+
+  # Attaching a Internet Gateway to route table makes it public.
+  PublicRouteTable:
+    Type: AWS::EC2::RouteTable
+    Properties:
+      VpcId: !Ref 'VPC'
+  PublicRoute:
+    Type: AWS::EC2::Route
+    DependsOn: GatewayAttachement
+    Properties:
+      RouteTableId: !Ref 'PublicRouteTable'
+      DestinationCidrBlock: '0.0.0.0/0'
+      GatewayId: !Ref 'InternetGateway'
+
+  # Attaching a public route table makes a subnet public.
+  PublicSubnetOneRouteTableAssociation:
+    Type: AWS::EC2::SubnetRouteTableAssociation
+    Properties:
+      SubnetId: !Ref PublicSubnetOne
+      RouteTableId: !Ref PublicRouteTable
+  PublicSubnetTwoRouteTableAssociation:
+    Type: AWS::EC2::SubnetRouteTableAssociation
+    Properties:
+      SubnetId: !Ref PublicSubnetTwo
+      RouteTableId: !Ref PublicRouteTable
+
+  # ECS Resources
+  ECSCluster:
+    Type: AWS::ECS::Cluster
+
+  # A role used to allow AWS Autoscaling to inspect stats and adjust scaleable targets
+  # on your AWS account
+  AutoscalingRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: [application-autoscaling.amazonaws.com]
+            Action: ['sts:AssumeRole']
+      Path: /
+      Policies:
+        - PolicyName: service-autoscaling
+          PolicyDocument:
+            Statement:
+              - Effect: Allow
+                Action:
+                  - 'application-autoscaling:*'
+                  - 'cloudwatch:DescribeAlarms'
+                  - 'cloudwatch:PutMetricAlarm'
+                  - 'ecs:DescribeServices'
+                  - 'ecs:UpdateService'
+                Resource: '*'
+
+  # This is an IAM role which authorizes ECS to manage resources on your
+  # account on your behalf, such as updating your load balancer with the
+  # details of where your containers are, so that traffic can reach your
+  # containers.
+  ECSRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: [ecs.amazonaws.com]
+            Action: ['sts:AssumeRole']
+      Path: /
+      Policies:
+        - PolicyName: ecs-service
+          PolicyDocument:
+            Statement:
+              - Effect: Allow
+                Action:
+                  # Rules which allow ECS to attach network interfaces to instances
+                  # on your behalf in order for awsvpc networking mode to work right
+                  - 'ec2:AttachNetworkInterface'
+                  - 'ec2:CreateNetworkInterface'
+                  - 'ec2:CreateNetworkInterfacePermission'
+                  - 'ec2:DeleteNetworkInterface'
+                  - 'ec2:DeleteNetworkInterfacePermission'
+                  - 'ec2:Describe*'
+                  - 'ec2:DetachNetworkInterface'
+
+                  # Rules which allow ECS to update load balancers on your behalf
+                  # with the information sabout how to send traffic to your containers
+                  - 'elasticloadbalancing:DeregisterInstancesFromLoadBalancer'
+                  - 'elasticloadbalancing:DeregisterTargets'
+                  - 'elasticloadbalancing:Describe*'
+                  - 'elasticloadbalancing:RegisterInstancesWithLoadBalancer'
+                  - 'elasticloadbalancing:RegisterTargets'
+                Resource: '*'
+
+  # This is a role which is used by the ECS tasks themselves.
+  ECSTaskExecutionRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: [ecs-tasks.amazonaws.com]
+            Action: ['sts:AssumeRole']
+      Path: /
+      Policies:
+        - PolicyName: AmazonECSTaskExecutionRolePolicy
+          PolicyDocument:
+            Statement:
+              - Effect: Allow
+                Action:
+                  # Allow the use of secret manager
+                  - 'secretsmanager:GetSecretValue'
+                  - 'kms:Decrypt'
+
+                  # Allow the ECS Tasks to download images from ECR
+                  - 'ecr:GetAuthorizationToken'
+                  - 'ecr:BatchCheckLayerAvailability'
+                  - 'ecr:GetDownloadUrlForLayer'
+                  - 'ecr:BatchGetImage'
+
+                  # Allow the ECS tasks to upload logs to CloudWatch
+                  - 'logs:CreateLogStream'
+                  - 'logs:PutLogEvents'
+                Resource: '*'
+
+  DeleteCFNLambdaExecutionRole:
+    Type: 'AWS::IAM::Role'
+    Properties:
+      AssumeRolePolicyDocument:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: 'Allow'
+            Principal:
+              Service: ['lambda.amazonaws.com']
+            Action: 'sts:AssumeRole'
+      Path: '/'
+      Policies:
+        - PolicyName: DeleteCFNLambdaExecutionRole
+          PolicyDocument:
+            Version: '2012-10-17'
+            Statement:
+              - Effect: 'Allow'
+                Action:
+                  - 'logs:CreateLogGroup'
+                  - 'logs:CreateLogStream'
+                  - 'logs:PutLogEvents'
+                Resource: 'arn:aws:logs:*:*:*'
+              - Effect: 'Allow'
+                Action:
+                  - 'cloudformation:DeleteStack'
+                  - 'kinesis:DeleteStream'
+                  - 'secretsmanager:DeleteSecret'
+                  - 'kinesis:DescribeStreamSummary'
+                  - 'logs:DeleteLogGroup'
+                  - 'logs:DeleteSubscriptionFilter'
+                  - 'ecs:DeregisterTaskDefinition'
+                  - 'lambda:DeleteFunction'
+                  - 'lambda:InvokeFunction'
+                  - 'events:RemoveTargets'
+                  - 'events:DeleteRule'
+                  - 'lambda:RemovePermission'
+                Resource: '*'
+
+  ### cloud watch to kinesis role
+  CloudWatchIAMRole:
+    Type: AWS::IAM::Role
+    Properties:
+      AssumeRolePolicyDocument:
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: [logs.amazonaws.com]
+            Action: ['sts:AssumeRole']
+      Path: /
+      Policies:
+        - PolicyName: service-autoscaling
+          PolicyDocument:
+            Statement:
+              - Effect: Allow
+                Action:
+                  - 'kinesis:PutRecord'
+                Resource: '*'
+
+  #####################EFS#####################
+  EfsFileStorage:
+    Type: 'AWS::EFS::FileSystem'
+    Properties:
+      BackupPolicy:
+        Status: ENABLED
+      PerformanceMode: maxIO
+      Encrypted: false
+
+      FileSystemPolicy:
+        Version: '2012-10-17'
+        Statement:
+          - Effect: 'Allow'
+            Action:
+              - 'elasticfilesystem:ClientMount'
+              - 'elasticfilesystem:ClientWrite'
+              - 'elasticfilesystem:ClientRootAccess'
+            Principal:
+              AWS: '*'
+
+  MountTargetResource1:
+    Type: AWS::EFS::MountTarget
+    Properties:
+      FileSystemId: !Ref EfsFileStorage
+      SubnetId: !Ref PublicSubnetOne
+      SecurityGroups:
+        - !Ref EFSServerSecurityGroup
+
+  MountTargetResource2:
+    Type: AWS::EFS::MountTarget
+    Properties:
+      FileSystemId: !Ref EfsFileStorage
+      SubnetId: !Ref PublicSubnetTwo
+      SecurityGroups:
+        - !Ref EFSServerSecurityGroup
+
+Outputs:
+  EfsFileStorageId:
+    Description: 'The connection endpoint for the database.'
+    Value: !Ref EfsFileStorage
+    Export:
+      Name: !Sub ${EnvironmentName}:EfsFileStorageId
+  ClusterName:
+    Description: The name of the ECS cluster
+    Value: !Ref 'ECSCluster'
+    Export:
+      Name: !Sub ${EnvironmentName}:ClusterName
+  AutoscalingRole:
+    Description: The ARN of the role used for autoscaling
+    Value: !GetAtt 'AutoscalingRole.Arn'
+    Export:
+      Name: !Sub ${EnvironmentName}:AutoscalingRole
+  ECSRole:
+    Description: The ARN of the ECS role
+    Value: !GetAtt 'ECSRole.Arn'
+    Export:
+      Name: !Sub ${EnvironmentName}:ECSRole
+  ECSTaskExecutionRole:
+    Description: The ARN of the ECS role tsk execution role
+    Value: !GetAtt 'ECSTaskExecutionRole.Arn'
+    Export:
+      Name: !Sub ${EnvironmentName}:ECSTaskExecutionRole
+
+  DeleteCFNLambdaExecutionRole:
+    Description: Lambda execution role for cleaning up cloud formations
+    Value: !GetAtt 'DeleteCFNLambdaExecutionRole.Arn'
+    Export:
+      Name: !Sub ${EnvironmentName}:DeleteCFNLambdaExecutionRole
+
+  CloudWatchIAMRole:
+    Description: The ARN of the CloudWatch role for subscription filter
+    Value: !GetAtt 'CloudWatchIAMRole.Arn'
+    Export:
+      Name: !Sub ${EnvironmentName}:CloudWatchIAMRole
+  VpcId:
+    Description: The ID of the VPC that this stack is deployed in
+    Value: !Ref 'VPC'
+    Export:
+      Name: !Sub ${EnvironmentName}:VpcId
+  PublicSubnetOne:
+    Description: Public subnet one
+    Value: !Ref 'PublicSubnetOne'
+    Export:
+      Name: !Sub ${EnvironmentName}:PublicSubnetOne
+  PublicSubnetTwo:
+    Description: Public subnet two
+    Value: !Ref 'PublicSubnetTwo'
+    Export:
+      Name: !Sub ${EnvironmentName}:PublicSubnetTwo
+
+  ContainerSecurityGroup:
+    Description: A security group used to allow Fargate containers to receive traffic
+    Value: !Ref 'ContainerSecurityGroup'
+    Export:
+      Name: !Sub ${EnvironmentName}:ContainerSecurityGroup
--- a/src/model/cloud-runner/aws/cloud-formations/task-def-formation.yml
+++ b/src/model/cloud-runner/aws/cloud-formations/task-def-formation.yml
@@ -0,0 +1,221 @@
+AWSTemplateFormatVersion: 2010-09-09
+Description: >-
+  AWS Fargate cluster that can span public and private subnets. Supports public
+  facing load balancers, private internal load balancers, and both internal and
+  external service discovery namespaces.
+Parameters:
+  EnvironmentName:
+    Type: String
+    Default: development
+    Description: 'Your deployment environment: DEV, QA , PROD'
+  ServiceName:
+    Type: String
+    Default: example
+    Description: A name for the service
+  ImageUrl:
+    Type: String
+    Default: nginx
+    Description: >-
+      The url of a docker image that contains the application process that will
+      handle the traffic for this service
+  ContainerPort:
+    Type: Number
+    Default: 80
+    Description: What port number the application inside the docker container is binding to
+  ContainerCpu:
+    Type: Number
+    Default: 1024
+    Description: How much CPU to give the container. 1024 is 1 CPU
+  ContainerMemory:
+    Type: Number
+    Default: 2048
+    Description: How much memory in megabytes to give the container
+  BUILDGUID:
+    Type: String
+    Default: ''
+  Command:
+    Type: String
+    Default: 'ls'
+  EntryPoint:
+    Type: String
+    Default: '/bin/sh'
+  WorkingDirectory:
+    Type: String
+    Default: '/efsdata/'
+  Role:
+    Type: String
+    Default: ''
+    Description: >-
+      (Optional) An IAM role to give the service's containers if the code within
+      needs to access other AWS resources like S3 buckets, DynamoDB tables, etc
+  EFSMountDirectory:
+    Type: String
+    Default: '/efsdata'
+  # template secrets p1 - input
+Mappings:
+  SubnetConfig:
+    VPC:
+      CIDR: 10.0.0.0/16
+    PublicOne:
+      CIDR: 10.0.0.0/24
+    PublicTwo:
+      CIDR: 10.0.1.0/24
+Conditions:
+  HasCustomRole: !Not
+    - !Equals
+      - Ref: Role
+      - ''
+Resources:
+  LogGroup:
+    Type: 'AWS::Logs::LogGroup'
+    Properties:
+      LogGroupName: !Ref ServiceName
+    Metadata:
+      'AWS::CloudFormation::Designer':
+        id: aece53ae-b82d-4267-bc16-ed964b05db27
+  SubscriptionFilter:
+    Type: 'AWS::Logs::SubscriptionFilter'
+    Properties:
+      FilterPattern: ''
+      RoleArn:
+        'Fn::ImportValue': !Sub '${EnvironmentName}:CloudWatchIAMRole'
+      LogGroupName: !Ref ServiceName
+      DestinationArn:
+        'Fn::GetAtt':
+          - KinesisStream
+          - Arn
+    Metadata:
+      'AWS::CloudFormation::Designer':
+        id: 7f809e91-9e5d-4678-98c1-c5085956c480
+    DependsOn:
+      - LogGroup
+      - KinesisStream
+  KinesisStream:
+    Type: 'AWS::Kinesis::Stream'
+    Properties:
+      Name: !Ref ServiceName
+      ShardCount: 1
+    Metadata:
+      'AWS::CloudFormation::Designer':
+        id: c6f18447-b879-4696-8873-f981b2cedd2b
+
+  # template secrets p2 - secret
+
+  TaskDefinition:
+    Type: 'AWS::ECS::TaskDefinition'
+    Properties:
+      Family: !Ref ServiceName
+      Cpu: !Ref ContainerCpu
+      Memory: !Ref ContainerMemory
+      NetworkMode: awsvpc
+      Volumes:
+        - Name: efs-data
+          EFSVolumeConfiguration:
+            FilesystemId:
+              'Fn::ImportValue': !Sub '${EnvironmentName}:EfsFileStorageId'
+            TransitEncryption: ENABLED
+      RequiresCompatibilities:
+        - FARGATE
+      ExecutionRoleArn:
+        'Fn::ImportValue': !Sub '${EnvironmentName}:ECSTaskExecutionRole'
+      TaskRoleArn:
+        'Fn::If':
+          - HasCustomRole
+          - !Ref Role
+          - !Ref 'AWS::NoValue'
+      ContainerDefinitions:
+        - Name: !Ref ServiceName
+          Cpu: !Ref ContainerCpu
+          Memory: !Ref ContainerMemory
+          Image: !Ref ImageUrl
+          EntryPoint:
+            Fn::Split:
+              - ','
+              - !Ref EntryPoint
+          Command:
+            Fn::Split:
+              - ','
+              - !Ref Command
+          WorkingDirectory: !Ref WorkingDirectory
+          Environment:
+            - Name: ALLOW_EMPTY_PASSWORD
+              Value: 'yes'
+            # template - env vars
+          MountPoints:
+            - SourceVolume: efs-data
+              ContainerPath: !Ref EFSMountDirectory
+              ReadOnly: false
+          Secrets:
+            # template secrets p3 - container def
+          LogConfiguration:
+            LogDriver: awslogs
+            Options:
+              awslogs-group: !Ref ServiceName
+              awslogs-region: !Ref 'AWS::Region'
+              awslogs-stream-prefix: !Ref ServiceName
+    Metadata:
+      'AWS::CloudFormation::Designer':
+        id: dabb0116-abe0-48a6-a8af-cf9111c879a5
+    DependsOn:
+      - LogGroup
+Metadata:
+  'AWS::CloudFormation::Designer':
+    dabb0116-abe0-48a6-a8af-cf9111c879a5:
+      size:
+        width: 60
+        height: 60
+      position:
+        x: 270
+        'y': 90
+      z: 1
+      embeds: []
+      dependson:
+        - aece53ae-b82d-4267-bc16-ed964b05db27
+    c6f18447-b879-4696-8873-f981b2cedd2b:
+      size:
+        width: 60
+        height: 60
+      position:
+        x: 270
+        'y': 210
+      z: 1
+      embeds: []
+    7f809e91-9e5d-4678-98c1-c5085956c480:
+      size:
+        width: 60
+        height: 60
+      position:
+        x: 60
+        'y': 300
+      z: 1
+      embeds: []
+      dependson:
+        - aece53ae-b82d-4267-bc16-ed964b05db27
+        - c6f18447-b879-4696-8873-f981b2cedd2b
+    aece53ae-b82d-4267-bc16-ed964b05db27:
+      size:
+        width: 150
+        height: 150
+      position:
+        x: 60
+        'y': 90
+      z: 1
+      embeds: []
+    4d2da56c-3643-46b8-aaee-e46e19f95fcc:
+      source:
+        id: 7f809e91-9e5d-4678-98c1-c5085956c480
+      target:
+        id: aece53ae-b82d-4267-bc16-ed964b05db27
+      z: 11
+    14eb957b-f094-4653-93c4-77b2f851953c:
+      source:
+        id: 7f809e91-9e5d-4678-98c1-c5085956c480
+      target:
+        id: c6f18447-b879-4696-8873-f981b2cedd2b
+      z: 12
+    85c57444-e5bb-4230-bc85-e545cd4558f6:
+      source:
+        id: dabb0116-abe0-48a6-a8af-cf9111c879a5
+      target:
+        id: aece53ae-b82d-4267-bc16-ed964b05db27
+      z: 13
--- a/src/model/cloud-runner/aws/cloud-runner-aws-task-def.ts
+++ b/src/model/cloud-runner/aws/cloud-runner-aws-task-def.ts
@@ -0,0 +1,9 @@
+import * as AWS from 'aws-sdk';
+
+class CloudRunnerAWSTaskDef {
+  public taskDefStackName!: string;
+  public taskDefCloudFormation!: string;
+  public taskDefResources: AWS.CloudFormation.StackResources | undefined;
+  public baseResources: AWS.CloudFormation.StackResources | undefined;
+}
+export default CloudRunnerAWSTaskDef;
--- a/src/model/cloud-runner/aws/index.ts
+++ b/src/model/cloud-runner/aws/index.ts
@@ -0,0 +1,98 @@
+import * as SDK from 'aws-sdk';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import CloudRunnerAWSTaskDef from './cloud-runner-aws-task-def';
+import AWSTaskRunner from './aws-task-runner';
+import { CloudRunnerProviderInterface } from '../services/cloud-runner-provider-interface';
+import BuildParameters from '../../build-parameters';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { AWSJobStack } from './aws-job-stack';
+import { AWSBaseStack } from './aws-base-stack';
+import { Input } from '../..';
+
+class AWSBuildEnvironment implements CloudRunnerProviderInterface {
+  private baseStackName: string;
+
+  constructor(buildParameters: BuildParameters) {
+    this.baseStackName = buildParameters.awsBaseStackName;
+  }
+  async cleanupSharedResources(
+    // eslint-disable-next-line no-unused-vars
+    buildGuid: string,
+    // eslint-disable-next-line no-unused-vars
+    buildParameters: BuildParameters,
+    // eslint-disable-next-line no-unused-vars
+    branchName: string,
+    // eslint-disable-next-line no-unused-vars
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {}
+  async setupSharedResources(
+    // eslint-disable-next-line no-unused-vars
+    buildGuid: string,
+    // eslint-disable-next-line no-unused-vars
+    buildParameters: BuildParameters,
+    // eslint-disable-next-line no-unused-vars
+    branchName: string,
+    // eslint-disable-next-line no-unused-vars
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {}
+
+  async runTask(
+    buildGuid: string,
+    image: string,
+    commands: string,
+    mountdir: string,
+    workingdir: string,
+    environment: CloudRunnerEnvironmentVariable[],
+    secrets: CloudRunnerSecret[],
+  ): Promise<string> {
+    process.env.AWS_REGION = Input.region;
+    const ECS = new SDK.ECS();
+    const CF = new SDK.CloudFormation();
+    CloudRunnerLogger.log(`AWS Region: ${CF.config.region}`);
+    const entrypoint = ['/bin/sh'];
+    const startTimeMs = Date.now();
+
+    await new AWSBaseStack(this.baseStackName).setupBaseStack(CF);
+    const taskDef = await new AWSJobStack(this.baseStackName).setupCloudFormations(
+      CF,
+      buildGuid,
+      image,
+      entrypoint,
+      commands,
+      mountdir,
+      workingdir,
+      secrets,
+    );
+
+    let postRunTaskTimeMs;
+    let output = '';
+    try {
+      const postSetupStacksTimeMs = Date.now();
+      CloudRunnerLogger.log(`Setup job time: ${Math.floor((postSetupStacksTimeMs - startTimeMs) / 1000)}s`);
+      output = await AWSTaskRunner.runTask(taskDef, ECS, CF, environment, buildGuid, commands);
+      postRunTaskTimeMs = Date.now();
+      CloudRunnerLogger.log(`Run job time: ${Math.floor((postRunTaskTimeMs - postSetupStacksTimeMs) / 1000)}s`);
+    } finally {
+      await this.cleanupResources(CF, taskDef);
+      const postCleanupTimeMs = Date.now();
+      if (postRunTaskTimeMs !== undefined)
+        CloudRunnerLogger.log(`Cleanup job time: ${Math.floor((postCleanupTimeMs - postRunTaskTimeMs) / 1000)}s`);
+    }
+    return output;
+  }
+
+  async cleanupResources(CF: SDK.CloudFormation, taskDef: CloudRunnerAWSTaskDef) {
+    CloudRunnerLogger.log('Cleanup starting');
+    await CF.deleteStack({
+      StackName: taskDef.taskDefStackName,
+    }).promise();
+
+    await CF.waitFor('stackDeleteComplete', {
+      StackName: taskDef.taskDefStackName,
+    }).promise();
+    CloudRunnerLogger.log(`Deleted Stack: ${taskDef.taskDefStackName}`);
+    CloudRunnerLogger.log('Cleanup complete');
+  }
+}
+export default AWSBuildEnvironment;
--- a/src/model/cloud-runner/cloud-runner-statics.ts
+++ b/src/model/cloud-runner/cloud-runner-statics.ts
@@ -0,0 +1,3 @@
+export class CloudRunnerStatics {
+  public static readonly logPrefix = `Cloud-Runner-System`;
+}
--- a/src/model/cloud-runner/cloud-runner.test.ts
+++ b/src/model/cloud-runner/cloud-runner.test.ts
@@ -0,0 +1,50 @@
+import { BuildParameters, ImageTag } from '..';
+import CloudRunner from './cloud-runner';
+import Input from '../input';
+import { CloudRunnerStatics } from './cloud-runner-statics';
+import { TaskParameterSerializer } from './services/task-parameter-serializer';
+import UnityVersioning from '../unity-versioning';
+
+describe('Cloud Runner', () => {
+  it('responds', () => {});
+});
+describe('Cloud Runner', () => {
+  const testSecretName = 'testSecretName';
+  const testSecretValue = 'testSecretValue';
+  if (Input.cloudRunnerTests) {
+    it('All build parameters sent to cloud runner as env vars', async () => {
+      Input.cliOptions = {
+        versioning: 'None',
+        projectPath: 'test-project',
+        unityVersion: UnityVersioning.read('test-project'),
+        customJob: `
+        - name: 'step 1'
+          image: 'alpine'
+          commands: 'printenv'
+          secrets:
+            - name: '${testSecretName}'
+              value: '${testSecretValue}'
+        `,
+      };
+      Input.githubInputEnabled = false;
+      const buildParameter = await BuildParameters.create();
+      const baseImage = new ImageTag(buildParameter);
+      const file = await CloudRunner.run(buildParameter, baseImage.toString());
+      expect(file).toContain(JSON.stringify(buildParameter));
+      expect(file).toContain(`${Input.ToEnvVarFormat(testSecretName)}=${testSecretValue}`);
+      const environmentVariables = TaskParameterSerializer.readBuildEnvironmentVariables();
+      const newLinePurgedFile = file
+        .replace(/\s+/g, '')
+        .replace(new RegExp(`\\[${CloudRunnerStatics.logPrefix}\\]`, 'g'), '');
+      for (const element of environmentVariables) {
+        if (element.value !== undefined && typeof element.value !== 'function') {
+          if (typeof element.value === `string`) {
+            element.value = element.value.replace(/\s+/g, '');
+          }
+          expect(newLinePurgedFile).toContain(`${element.name}=${element.value}`);
+        }
+      }
+      Input.githubInputEnabled = true;
+    }, 1000000);
+  }
+});
--- a/src/model/cloud-runner/cloud-runner.ts
+++ b/src/model/cloud-runner/cloud-runner.ts
@@ -0,0 +1,72 @@
+import AWSBuildPlatform from './aws';
+import { BuildParameters } from '..';
+import { CloudRunnerState } from './state/cloud-runner-state';
+import Kubernetes from './k8s';
+import CloudRunnerLogger from './services/cloud-runner-logger';
+import { CloudRunnerStepState } from './state/cloud-runner-step-state';
+import { WorkflowCompositionRoot } from './workflows/workflow-composition-root';
+import { CloudRunnerError } from './error/cloud-runner-error';
+import { TaskParameterSerializer } from './services/task-parameter-serializer';
+import * as core from '@actions/core';
+
+class CloudRunner {
+  private static setup(buildParameters: BuildParameters) {
+    CloudRunnerLogger.setup();
+    CloudRunnerState.setup(buildParameters);
+    CloudRunner.setupBuildPlatform();
+    const parameters = TaskParameterSerializer.readBuildEnvironmentVariables();
+    for (const element of parameters) {
+      core.setOutput(element.name, element.value);
+    }
+  }
+
+  private static setupBuildPlatform() {
+    switch (CloudRunnerState.buildParams.cloudRunnerCluster) {
+      case 'k8s':
+        CloudRunnerLogger.log('Cloud Runner platform selected Kubernetes');
+        CloudRunnerState.CloudRunnerProviderPlatform = new Kubernetes(CloudRunnerState.buildParams);
+        break;
+      default:
+      case 'aws':
+        CloudRunnerLogger.log('Cloud Runner platform selected AWS');
+        CloudRunnerState.CloudRunnerProviderPlatform = new AWSBuildPlatform(CloudRunnerState.buildParams);
+        break;
+    }
+  }
+
+  static async run(buildParameters: BuildParameters, baseImage: string) {
+    CloudRunner.setup(buildParameters);
+    try {
+      core.startGroup('Setup remote runner');
+      await CloudRunnerState.CloudRunnerProviderPlatform.setupSharedResources(
+        CloudRunnerState.buildParams.buildGuid,
+        CloudRunnerState.buildParams,
+        CloudRunnerState.branchName,
+        CloudRunnerState.defaultSecrets,
+      );
+      core.endGroup();
+      const output = await new WorkflowCompositionRoot().run(
+        new CloudRunnerStepState(
+          baseImage,
+          TaskParameterSerializer.readBuildEnvironmentVariables(),
+          CloudRunnerState.defaultSecrets,
+        ),
+      );
+      core.startGroup('Cleanup');
+      await CloudRunnerState.CloudRunnerProviderPlatform.cleanupSharedResources(
+        CloudRunnerState.buildParams.buildGuid,
+        CloudRunnerState.buildParams,
+        CloudRunnerState.branchName,
+        CloudRunnerState.defaultSecrets,
+      );
+      CloudRunnerLogger.log(`Cleanup complete`);
+      core.endGroup();
+      return output;
+    } catch (error) {
+      core.endGroup();
+      await CloudRunnerError.handleException(error);
+      throw error;
+    }
+  }
+}
+export default CloudRunner;
--- a/src/model/cloud-runner/error/cloud-runner-error.ts
+++ b/src/model/cloud-runner/error/cloud-runner-error.ts
@@ -0,0 +1,16 @@
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import * as core from '@actions/core';
+
+export class CloudRunnerError {
+  public static async handleException(error: unknown) {
+    CloudRunnerLogger.error(JSON.stringify(error, undefined, 4));
+    core.setFailed('Cloud Runner failed');
+    await CloudRunnerState.CloudRunnerProviderPlatform.cleanupSharedResources(
+      CloudRunnerState.buildParams.buildGuid,
+      CloudRunnerState.buildParams,
+      CloudRunnerState.branchName,
+      CloudRunnerState.defaultSecrets,
+    );
+  }
+}
--- a/src/model/cloud-runner/k8s/index.ts
+++ b/src/model/cloud-runner/k8s/index.ts
@@ -0,0 +1,197 @@
+import * as k8s from '@kubernetes/client-node';
+import { BuildParameters, Output } from '../..';
+import * as core from '@actions/core';
+import { CloudRunnerProviderInterface } from '../services/cloud-runner-provider-interface';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import KubernetesStorage from './kubernetes-storage';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import KubernetesTaskRunner from './kubernetes-task-runner';
+import KubernetesSecret from './kubernetes-secret';
+import waitUntil from 'async-wait-until';
+import KubernetesJobSpecFactory from './kubernetes-job-spec-factory';
+import KubernetesServiceAccount from './kubernetes-service-account';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { CoreV1Api } from '@kubernetes/client-node';
+
+class Kubernetes implements CloudRunnerProviderInterface {
+  private kubeConfig: k8s.KubeConfig;
+  private kubeClient: k8s.CoreV1Api;
+  private kubeClientBatch: k8s.BatchV1Api;
+  private buildGuid: string = '';
+  private buildParameters: BuildParameters;
+  private pvcName: string = '';
+  private secretName: string = '';
+  private jobName: string = '';
+  private namespace: string;
+  private podName: string = '';
+  private containerName: string = '';
+  private cleanupCronJobName: string = '';
+  private serviceAccountName: string = '';
+
+  constructor(buildParameters: BuildParameters) {
+    this.kubeConfig = new k8s.KubeConfig();
+    this.kubeConfig.loadFromDefault();
+    this.kubeClient = this.kubeConfig.makeApiClient(k8s.CoreV1Api);
+    this.kubeClientBatch = this.kubeConfig.makeApiClient(k8s.BatchV1Api);
+    CloudRunnerLogger.log('Loaded default Kubernetes configuration for this environment');
+
+    this.namespace = 'default';
+    this.buildParameters = buildParameters;
+  }
+  public async setupSharedResources(
+    buildGuid: string,
+    buildParameters: BuildParameters,
+    // eslint-disable-next-line no-unused-vars
+    branchName: string,
+    // eslint-disable-next-line no-unused-vars
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {
+    try {
+      this.pvcName = `unity-builder-pvc-${buildGuid}`;
+      this.cleanupCronJobName = `unity-builder-cronjob-${buildGuid}`;
+      this.serviceAccountName = `service-account-${buildGuid}`;
+      await KubernetesStorage.createPersistentVolumeClaim(
+        buildParameters,
+        this.pvcName,
+        this.kubeClient,
+        this.namespace,
+      );
+
+      await KubernetesServiceAccount.createServiceAccount(this.serviceAccountName, this.namespace, this.kubeClient);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async runTask(
+    buildGuid: string,
+    image: string,
+    commands: string,
+    mountdir: string,
+    workingdir: string,
+    environment: CloudRunnerEnvironmentVariable[],
+    secrets: CloudRunnerSecret[],
+  ): Promise<string> {
+    try {
+      // setup
+      this.buildGuid = buildGuid;
+      this.secretName = `build-credentials-${buildGuid}`;
+      this.jobName = `unity-builder-job-${buildGuid}`;
+      this.containerName = `main`;
+      await KubernetesSecret.createSecret(secrets, this.secretName, this.namespace, this.kubeClient);
+      const jobSpec = KubernetesJobSpecFactory.getJobSpec(
+        commands,
+        image,
+        mountdir,
+        workingdir,
+        environment,
+        secrets,
+        this.buildGuid,
+        this.buildParameters,
+        this.secretName,
+        this.pvcName,
+        this.jobName,
+        k8s,
+      );
+
+      //run
+      const jobResult = await this.kubeClientBatch.createNamespacedJob(this.namespace, jobSpec);
+      CloudRunnerLogger.log(`Creating build job ${JSON.stringify(jobResult.body.metadata, undefined, 4)}`);
+
+      await new Promise((promise) => setTimeout(promise, 5000));
+      CloudRunnerLogger.log('Job created');
+      this.setPodNameAndContainerName(await Kubernetes.findPodFromJob(this.kubeClient, this.jobName, this.namespace));
+      CloudRunnerLogger.log('Watching pod until running');
+      let output = '';
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        try {
+          await KubernetesTaskRunner.watchUntilPodRunning(this.kubeClient, this.podName, this.namespace);
+          CloudRunnerLogger.log('Pod running, streaming logs');
+          output = await KubernetesTaskRunner.runTask(
+            this.kubeConfig,
+            this.kubeClient,
+            this.jobName,
+            this.podName,
+            'main',
+            this.namespace,
+            CloudRunnerLogger.log,
+          );
+          break;
+        } catch (error: any) {
+          if (error.message.includes(`HTTP`)) {
+            continue;
+          } else {
+            throw error;
+          }
+        }
+      }
+      await this.cleanupTaskResources();
+      return output;
+    } catch (error) {
+      CloudRunnerLogger.log('Running job failed');
+      core.error(JSON.stringify(error, undefined, 4));
+      await this.cleanupTaskResources();
+      throw error;
+    }
+  }
+
+  setPodNameAndContainerName(pod: k8s.V1Pod) {
+    this.podName = pod.metadata?.name || '';
+    this.containerName = pod.status?.containerStatuses?.[0].name || '';
+  }
+
+  async cleanupTaskResources() {
+    CloudRunnerLogger.log('cleaning up');
+    try {
+      await this.kubeClientBatch.deleteNamespacedJob(this.jobName, this.namespace);
+      await this.kubeClient.deleteNamespacedPod(this.podName, this.namespace);
+      await this.kubeClient.deleteNamespacedSecret(this.secretName, this.namespace);
+      await new Promise((promise) => setTimeout(promise, 5000));
+    } catch (error) {
+      CloudRunnerLogger.log('Failed to cleanup, error:');
+      core.error(JSON.stringify(error, undefined, 4));
+      CloudRunnerLogger.log('Abandoning cleanup, build error:');
+      throw error;
+    }
+    try {
+      await waitUntil(
+        async () => {
+          const jobBody = (await this.kubeClientBatch.readNamespacedJob(this.jobName, this.namespace)).body;
+          const podBody = (await this.kubeClient.readNamespacedPod(this.podName, this.namespace)).body;
+          return (jobBody === null || jobBody.status?.active === 0) && podBody === null;
+        },
+        {
+          timeout: 500000,
+          intervalBetweenAttempts: 15000,
+        },
+      );
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+
+  async cleanupSharedResources(
+    buildGuid: string,
+    buildParameters: BuildParameters,
+    // eslint-disable-next-line no-unused-vars
+    branchName: string,
+    // eslint-disable-next-line no-unused-vars
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  ) {
+    CloudRunnerLogger.log(`deleting PVC`);
+    await this.kubeClient.deleteNamespacedPersistentVolumeClaim(this.pvcName, this.namespace);
+    await Output.setBuildVersion(buildParameters.buildVersion);
+    // eslint-disable-next-line unicorn/no-process-exit
+    process.exit();
+  }
+
+  static async findPodFromJob(kubeClient: CoreV1Api, jobName: string, namespace: string) {
+    const namespacedPods = await kubeClient.listNamespacedPod(namespace);
+    const pod = namespacedPods.body.items.find((x) => x.metadata?.labels?.['job-name'] === jobName);
+    if (pod === undefined) {
+      throw new Error("pod with job-name label doesn't exist");
+    }
+    return pod;
+  }
+}
+export default Kubernetes;
--- a/src/model/cloud-runner/k8s/kubernetes-job-spec-factory.ts
+++ b/src/model/cloud-runner/k8s/kubernetes-job-spec-factory.ts
@@ -0,0 +1,161 @@
+import { V1EnvVar, V1EnvVarSource, V1SecretKeySelector } from '@kubernetes/client-node';
+import BuildParameters from '../../build-parameters';
+import { CloudRunnerBuildCommandProcessor } from '../services/cloud-runner-build-command-process';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+
+class KubernetesJobSpecFactory {
+  static getJobSpec(
+    command: string,
+    image: string,
+    mountdir: string,
+    workingDirectory: string,
+    environment: CloudRunnerEnvironmentVariable[],
+    secrets: CloudRunnerSecret[],
+    buildGuid: string,
+    buildParameters: BuildParameters,
+    secretName,
+    pvcName,
+    jobName,
+    k8s,
+  ) {
+    environment.push(
+      ...[
+        {
+          name: 'GITHUB_SHA',
+          value: buildGuid,
+        },
+        {
+          name: 'GITHUB_WORKSPACE',
+          value: '/data/repo',
+        },
+        {
+          name: 'PROJECT_PATH',
+          value: buildParameters.projectPath,
+        },
+        {
+          name: 'BUILD_PATH',
+          value: buildParameters.buildPath,
+        },
+        {
+          name: 'BUILD_FILE',
+          value: buildParameters.buildFile,
+        },
+        {
+          name: 'BUILD_NAME',
+          value: buildParameters.buildName,
+        },
+        {
+          name: 'BUILD_METHOD',
+          value: buildParameters.buildMethod,
+        },
+        {
+          name: 'CUSTOM_PARAMETERS',
+          value: buildParameters.customParameters,
+        },
+        {
+          name: 'CHOWN_FILES_TO',
+          value: buildParameters.chownFilesTo,
+        },
+        {
+          name: 'BUILD_TARGET',
+          value: buildParameters.platform,
+        },
+        {
+          name: 'ANDROID_VERSION_CODE',
+          value: buildParameters.androidVersionCode.toString(),
+        },
+        {
+          name: 'ANDROID_KEYSTORE_NAME',
+          value: buildParameters.androidKeystoreName,
+        },
+        {
+          name: 'ANDROID_KEYALIAS_NAME',
+          value: buildParameters.androidKeyaliasName,
+        },
+      ],
+    );
+    const job = new k8s.V1Job();
+    job.apiVersion = 'batch/v1';
+    job.kind = 'Job';
+    job.metadata = {
+      name: jobName,
+      labels: {
+        app: 'unity-builder',
+        buildGuid,
+      },
+    };
+    job.spec = {
+      backoffLimit: 0,
+      template: {
+        spec: {
+          volumes: [
+            {
+              name: 'build-mount',
+              persistentVolumeClaim: {
+                claimName: pvcName,
+              },
+            },
+          ],
+          containers: [
+            {
+              name: 'main',
+              image,
+              command: ['/bin/sh'],
+              args: ['-c', CloudRunnerBuildCommandProcessor.ProcessCommands(command, CloudRunnerState.buildParams)],
+
+              workingDir: `${workingDirectory}`,
+              resources: {
+                requests: {
+                  memory: buildParameters.cloudRunnerMemory,
+                  cpu: buildParameters.cloudRunnerCpu,
+                },
+              },
+              env: [
+                ...environment.map((x) => {
+                  const environmentVariable = new V1EnvVar();
+                  environmentVariable.name = x.name;
+                  environmentVariable.value = x.value;
+                  return environmentVariable;
+                }),
+                ...secrets.map((x) => {
+                  const secret = new V1EnvVarSource();
+                  secret.secretKeyRef = new V1SecretKeySelector();
+                  secret.secretKeyRef.key = x.ParameterKey;
+                  secret.secretKeyRef.name = secretName;
+                  const environmentVariable = new V1EnvVar();
+                  environmentVariable.name = x.EnvironmentVariable;
+                  environmentVariable.valueFrom = secret;
+                  return environmentVariable;
+                }),
+              ],
+              volumeMounts: [
+                {
+                  name: 'build-mount',
+                  mountPath: `/${mountdir}`,
+                },
+              ],
+              lifecycle: {
+                preStop: {
+                  exec: {
+                    command: [
+                      'bin/bash',
+                      '-c',
+                      `cd /data/builder/action/steps;
+                      chmod +x /return_license.sh;
+                      /return_license.sh;`,
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+          restartPolicy: 'Never',
+        },
+      },
+    };
+    return job;
+  }
+}
+export default KubernetesJobSpecFactory;
--- a/src/model/cloud-runner/k8s/kubernetes-secret.ts
+++ b/src/model/cloud-runner/k8s/kubernetes-secret.ts
@@ -0,0 +1,28 @@
+import { CoreV1Api } from '@kubernetes/client-node';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import * as k8s from '@kubernetes/client-node';
+const base64 = require('base-64');
+
+class KubernetesSecret {
+  static async createSecret(
+    secrets: CloudRunnerSecret[],
+    secretName: string,
+    namespace: string,
+    kubeClient: CoreV1Api,
+  ) {
+    const secret = new k8s.V1Secret();
+    secret.apiVersion = 'v1';
+    secret.kind = 'Secret';
+    secret.type = 'Opaque';
+    secret.metadata = {
+      name: secretName,
+    };
+    secret.data = {};
+    for (const buildSecret of secrets) {
+      secret.data[buildSecret.ParameterKey] = base64.encode(buildSecret.ParameterValue);
+    }
+    return kubeClient.createNamespacedSecret(namespace, secret);
+  }
+}
+
+export default KubernetesSecret;
--- a/src/model/cloud-runner/k8s/kubernetes-service-account.ts
+++ b/src/model/cloud-runner/k8s/kubernetes-service-account.ts
@@ -0,0 +1,17 @@
+import { CoreV1Api } from '@kubernetes/client-node';
+import * as k8s from '@kubernetes/client-node';
+
+class KubernetesServiceAccount {
+  static async createServiceAccount(serviceAccountName: string, namespace: string, kubeClient: CoreV1Api) {
+    const serviceAccount = new k8s.V1ServiceAccount();
+    serviceAccount.apiVersion = 'v1';
+    serviceAccount.kind = 'ServiceAccount';
+    serviceAccount.metadata = {
+      name: serviceAccountName,
+    };
+    serviceAccount.automountServiceAccountToken = false;
+    return kubeClient.createNamespacedServiceAccount(namespace, serviceAccount);
+  }
+}
+
+export default KubernetesServiceAccount;
--- a/src/model/cloud-runner/k8s/kubernetes-storage.ts
+++ b/src/model/cloud-runner/k8s/kubernetes-storage.ts
@@ -0,0 +1,114 @@
+import waitUntil from 'async-wait-until';
+import * as core from '@actions/core';
+import * as k8s from '@kubernetes/client-node';
+import BuildParameters from '../../build-parameters';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import YAML from 'yaml';
+
+class KubernetesStorage {
+  public static async createPersistentVolumeClaim(
+    buildParameters: BuildParameters,
+    pvcName: string,
+    kubeClient: k8s.CoreV1Api,
+    namespace: string,
+  ) {
+    if (buildParameters.kubeVolume) {
+      CloudRunnerLogger.log(buildParameters.kubeVolume);
+      pvcName = buildParameters.kubeVolume;
+      return;
+    }
+    const pvcList = (await kubeClient.listNamespacedPersistentVolumeClaim(namespace)).body.items.map(
+      (x) => x.metadata?.name,
+    );
+    CloudRunnerLogger.log(`Current PVCs in namespace ${namespace}`);
+    CloudRunnerLogger.log(JSON.stringify(pvcList, undefined, 4));
+    if (pvcList.includes(pvcName)) {
+      CloudRunnerLogger.log(`pvc ${pvcName} already exists`);
+      core.setOutput('volume', pvcName);
+      return;
+    }
+    CloudRunnerLogger.log(`Creating PVC ${pvcName} (does not exist)`);
+    const result = await KubernetesStorage.createPVC(pvcName, buildParameters, kubeClient, namespace);
+    await KubernetesStorage.handleResult(result, kubeClient, namespace, pvcName);
+  }
+
+  public static async getPVCPhase(kubeClient: k8s.CoreV1Api, name: string, namespace: string) {
+    try {
+      return (await kubeClient.readNamespacedPersistentVolumeClaim(name, namespace)).body.status?.phase;
+    } catch (error) {
+      core.error('Failed to get PVC phase');
+      core.error(JSON.stringify(error, undefined, 4));
+      throw error;
+    }
+  }
+
+  public static async watchUntilPVCNotPending(kubeClient: k8s.CoreV1Api, name: string, namespace: string) {
+    try {
+      CloudRunnerLogger.log(`watch Until PVC Not Pending ${name} ${namespace}`);
+      CloudRunnerLogger.log(`${await this.getPVCPhase(kubeClient, name, namespace)}`);
+      await waitUntil(
+        async () => {
+          return (await this.getPVCPhase(kubeClient, name, namespace)) !== 'Pending';
+        },
+        {
+          timeout: 500000,
+          intervalBetweenAttempts: 15000,
+        },
+      );
+    } catch (error: any) {
+      core.error('Failed to watch PVC');
+      core.error(error.toString());
+      core.error(
+        `PVC Body: ${JSON.stringify(
+          (await kubeClient.readNamespacedPersistentVolumeClaim(name, namespace)).body,
+          undefined,
+          4,
+        )}`,
+      );
+      throw error;
+    }
+  }
+
+  private static async createPVC(
+    pvcName: string,
+    buildParameters: BuildParameters,
+    kubeClient: k8s.CoreV1Api,
+    namespace: string,
+  ) {
+    const pvc = new k8s.V1PersistentVolumeClaim();
+    pvc.apiVersion = 'v1';
+    pvc.kind = 'PersistentVolumeClaim';
+    pvc.metadata = {
+      name: pvcName,
+    };
+    pvc.spec = {
+      accessModes: ['ReadWriteOnce'],
+      storageClassName: process.env.K8s_STORAGE_CLASS || 'standard',
+      resources: {
+        requests: {
+          storage: buildParameters.kubeVolumeSize,
+        },
+      },
+    };
+    if (process.env.K8s_STORAGE_PVC_SPEC) {
+      YAML.parse(process.env.K8s_STORAGE_PVC_SPEC);
+    }
+    const result = await kubeClient.createNamespacedPersistentVolumeClaim(namespace, pvc);
+    return result;
+  }
+
+  private static async handleResult(
+    result: { response: import('http').IncomingMessage; body: k8s.V1PersistentVolumeClaim },
+    kubeClient: k8s.CoreV1Api,
+    namespace: string,
+    pvcName: string,
+  ) {
+    const name = result.body.metadata?.name || '';
+    CloudRunnerLogger.log(`PVC ${name} created`);
+    await this.watchUntilPVCNotPending(kubeClient, name, namespace);
+    CloudRunnerLogger.log(`PVC ${name} is ready and not pending`);
+    core.setOutput('volume', pvcName);
+  }
+}
+
+export default KubernetesStorage;
--- a/src/model/cloud-runner/k8s/kubernetes-task-runner.ts
+++ b/src/model/cloud-runner/k8s/kubernetes-task-runner.ts
@@ -0,0 +1,104 @@
+import { CoreV1Api, KubeConfig, Log } from '@kubernetes/client-node';
+import { Writable } from 'stream';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import * as core from '@actions/core';
+import { CloudRunnerStatics } from '../cloud-runner-statics';
+import waitUntil from 'async-wait-until';
+import { Input } from '../..';
+
+class KubernetesTaskRunner {
+  static async runTask(
+    kubeConfig: KubeConfig,
+    kubeClient: CoreV1Api,
+    jobName: string,
+    podName: string,
+    containerName: string,
+    namespace: string,
+    logCallback: any,
+  ) {
+    CloudRunnerLogger.log(`Streaming logs from pod: ${podName} container: ${containerName} namespace: ${namespace}`);
+    const stream = new Writable();
+    let output = '';
+    let didStreamAnyLogs: boolean = false;
+    stream._write = (chunk, encoding, next) => {
+      didStreamAnyLogs = true;
+      let message = chunk.toString().trimRight(`\n`);
+      message = `[${CloudRunnerStatics.logPrefix}] ${message}`;
+      if (Input.cloudRunnerTests) {
+        output += message;
+      }
+      logCallback(message);
+      next();
+    };
+    const logOptions = {
+      follow: true,
+      pretty: false,
+      previous: false,
+    };
+    try {
+      const resultError = await new Promise((resolve) =>
+        new Log(kubeConfig).log(namespace, podName, containerName, stream, resolve, logOptions),
+      );
+      stream.destroy();
+      if (resultError) {
+        throw resultError;
+      }
+      if (!didStreamAnyLogs) {
+        core.error('Failed to stream any logs, listing namespace events, check for an error with the container');
+        core.error(
+          JSON.stringify(
+            {
+              events: (await kubeClient.listNamespacedEvent(namespace)).body.items
+                .filter((x) => {
+                  return x.involvedObject.name === podName || x.involvedObject.name === jobName;
+                })
+                .map((x) => {
+                  return {
+                    type: x.involvedObject.kind,
+                    name: x.involvedObject.name,
+                    message: x.message,
+                  };
+                }),
+            },
+            undefined,
+            4,
+          ),
+        );
+        throw new Error(`No logs streamed from k8s`);
+      }
+    } catch (error) {
+      if (stream) {
+        stream.destroy();
+      }
+      throw error;
+    }
+    CloudRunnerLogger.log('end of log stream');
+    return output;
+  }
+
+  static async watchUntilPodRunning(kubeClient: CoreV1Api, podName: string, namespace: string) {
+    let success: boolean = false;
+    CloudRunnerLogger.log(`Watching ${podName} ${namespace}`);
+    await waitUntil(
+      async () => {
+        const status = await kubeClient.readNamespacedPodStatus(podName, namespace);
+        const phase = status?.body.status?.phase;
+        success = phase === 'Running';
+        CloudRunnerLogger.log(
+          `${status.body.status?.phase} ${status.body.status?.conditions?.[0].reason || ''} ${
+            status.body.status?.conditions?.[0].message || ''
+          }`,
+        );
+        if (success || phase !== 'Pending') return true;
+        return false;
+      },
+      {
+        timeout: 2000000,
+        intervalBetweenAttempts: 15000,
+      },
+    );
+    return success;
+  }
+}
+
+export default KubernetesTaskRunner;
--- a/src/model/cloud-runner/services/cloud-runner-build-command-process.ts
+++ b/src/model/cloud-runner/services/cloud-runner-build-command-process.ts
@@ -0,0 +1,40 @@
+import { BuildParameters, Input } from '../..';
+import YAML from 'yaml';
+import CloudRunnerSecret from './cloud-runner-secret';
+
+export class CloudRunnerBuildCommandProcessor {
+  public static ProcessCommands(commands: string, buildParameters: BuildParameters): string {
+    const hooks = CloudRunnerBuildCommandProcessor.getHooks().filter((x) => x.step.includes(`all`));
+
+    return `echo "---"
+      echo "start cloud runner init"
+      ${Input.cloudRunnerTests ? '' : '#'} printenv
+      echo "start cloud runner job"
+      ${hooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
+      ${commands}
+      ${hooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
+      echo "end of cloud runner job
+      ---${buildParameters.logId}"
+    `;
+  }
+
+  public static getHooks(): Hook[] {
+    const experimentHooks = process.env.EXPERIMENTAL_HOOKS;
+    let output = new Array<Hook>();
+    if (experimentHooks && experimentHooks !== '') {
+      try {
+        output = YAML.parse(experimentHooks);
+      } catch (error) {
+        throw error;
+      }
+    }
+    return output.filter((x) => x.step !== undefined && x.hook !== undefined && x.hook.length > 0);
+  }
+}
+export class Hook {
+  public commands;
+  public secrets: CloudRunnerSecret[] = new Array<CloudRunnerSecret>();
+  public name;
+  public hook!: string[];
+  public step!: string[];
+}
--- a/src/model/cloud-runner/services/cloud-runner-constants.ts
+++ b/src/model/cloud-runner/services/cloud-runner-constants.ts
@@ -0,0 +1,4 @@
+class CloudRunnerConstants {
+  static alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+}
+export default CloudRunnerConstants;
--- a/src/model/cloud-runner/services/cloud-runner-environment-variable.ts
+++ b/src/model/cloud-runner/services/cloud-runner-environment-variable.ts
@@ -0,0 +1,5 @@
+class CloudRunnerEnvironmentVariable {
+  public name!: string;
+  public value!: string;
+}
+export default CloudRunnerEnvironmentVariable;
--- a/src/model/cloud-runner/services/cloud-runner-logger.ts
+++ b/src/model/cloud-runner/services/cloud-runner-logger.ts
@@ -0,0 +1,47 @@
+import * as core from '@actions/core';
+
+class CloudRunnerLogger {
+  private static timestamp: number;
+  private static globalTimestamp: number;
+
+  public static setup() {
+    this.timestamp = this.createTimestamp();
+    this.globalTimestamp = this.timestamp;
+  }
+
+  public static log(message: string) {
+    core.info(message);
+  }
+
+  public static logWarning(message: string) {
+    core.warning(message);
+  }
+
+  public static logLine(message: string) {
+    core.info(`${message}\n`);
+  }
+
+  public static error(message: string) {
+    core.error(message);
+  }
+
+  public static logWithTime(message: string) {
+    const newTimestamp = this.createTimestamp();
+    core.info(
+      `${message} (Since previous: ${this.calculateTimeDiff(
+        newTimestamp,
+        this.timestamp,
+      )}, Total time: ${this.calculateTimeDiff(newTimestamp, this.globalTimestamp)})`,
+    );
+    this.timestamp = newTimestamp;
+  }
+
+  private static calculateTimeDiff(x: number, y: number) {
+    return Math.floor((x - y) / 1000);
+  }
+
+  private static createTimestamp() {
+    return Date.now();
+  }
+}
+export default CloudRunnerLogger;
--- a/src/model/cloud-runner/services/cloud-runner-namespace.ts
+++ b/src/model/cloud-runner/services/cloud-runner-namespace.ts
@@ -0,0 +1,10 @@
+import { customAlphabet } from 'nanoid';
+import CloudRunnerConstants from './cloud-runner-constants';
+
+class CloudRunnerNamespace {
+  static generateBuildName(runNumber: string | number, platform: string) {
+    const nanoid = customAlphabet(CloudRunnerConstants.alphabet, 4);
+    return `${runNumber}-${platform.toLowerCase().replace('standalone', '')}-${nanoid()}`;
+  }
+}
+export default CloudRunnerNamespace;
--- a/src/model/cloud-runner/services/cloud-runner-provider-interface.ts
+++ b/src/model/cloud-runner/services/cloud-runner-provider-interface.ts
@@ -0,0 +1,42 @@
+import BuildParameters from '../../build-parameters';
+import CloudRunnerEnvironmentVariable from './cloud-runner-environment-variable';
+import CloudRunnerSecret from './cloud-runner-secret';
+
+export interface CloudRunnerProviderInterface {
+  cleanupSharedResources(
+    // eslint-disable-next-line no-unused-vars
+    buildGuid: string,
+    // eslint-disable-next-line no-unused-vars
+    buildParameters: BuildParameters,
+    // eslint-disable-next-line no-unused-vars
+    branchName: string,
+    // eslint-disable-next-line no-unused-vars
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  );
+  setupSharedResources(
+    // eslint-disable-next-line no-unused-vars
+    buildGuid: string,
+    // eslint-disable-next-line no-unused-vars
+    buildParameters: BuildParameters,
+    // eslint-disable-next-line no-unused-vars
+    branchName: string,
+    // eslint-disable-next-line no-unused-vars
+    defaultSecretsArray: { ParameterKey: string; EnvironmentVariable: string; ParameterValue: string }[],
+  );
+  runTask(
+    // eslint-disable-next-line no-unused-vars
+    buildGuid: string,
+    // eslint-disable-next-line no-unused-vars
+    image: string,
+    // eslint-disable-next-line no-unused-vars
+    commands: string,
+    // eslint-disable-next-line no-unused-vars
+    mountdir: string,
+    // eslint-disable-next-line no-unused-vars
+    workingdir: string,
+    // eslint-disable-next-line no-unused-vars
+    environment: CloudRunnerEnvironmentVariable[],
+    // eslint-disable-next-line no-unused-vars
+    secrets: CloudRunnerSecret[],
+  ): Promise<string>;
+}
--- a/src/model/cloud-runner/services/cloud-runner-secret.ts
+++ b/src/model/cloud-runner/services/cloud-runner-secret.ts
@@ -0,0 +1,6 @@
+class CloudRunnerSecret {
+  public ParameterKey!: string;
+  public EnvironmentVariable!: string;
+  public ParameterValue!: string;
+}
+export default CloudRunnerSecret;
--- a/src/model/cloud-runner/services/task-parameter-serializer.ts
+++ b/src/model/cloud-runner/services/task-parameter-serializer.ts
@@ -0,0 +1,85 @@
+import { Input } from '../..';
+import ImageEnvironmentFactory from '../../image-environment-factory';
+import CloudRunnerEnvironmentVariable from './cloud-runner-environment-variable';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import { CloudRunnerBuildCommandProcessor } from './cloud-runner-build-command-process';
+
+export class TaskParameterSerializer {
+  public static readBuildEnvironmentVariables(): CloudRunnerEnvironmentVariable[] {
+    TaskParameterSerializer.setupDefaultSecrets();
+    return [
+      {
+        name: 'ContainerMemory',
+        value: CloudRunnerState.buildParams.cloudRunnerMemory,
+      },
+      {
+        name: 'ContainerCpu',
+        value: CloudRunnerState.buildParams.cloudRunnerCpu,
+      },
+      {
+        name: 'BUILD_TARGET',
+        value: CloudRunnerState.buildParams.platform,
+      },
+      ...TaskParameterSerializer.serializeBuildParamsAndInput,
+    ];
+  }
+  private static get serializeBuildParamsAndInput() {
+    let array = new Array();
+    array = TaskParameterSerializer.readBuildParameters(array);
+    array = TaskParameterSerializer.readInput(array);
+    const configurableHooks = CloudRunnerBuildCommandProcessor.getHooks();
+    const secrets = configurableHooks.map((x) => x.secrets).filter((x) => x !== undefined && x.length > 0);
+    if (secrets.length > 0) {
+      // eslint-disable-next-line unicorn/no-array-reduce
+      array.push(secrets.reduce((x, y) => [...x, ...y]));
+    }
+
+    array = array.filter(
+      (x) => x.value !== undefined && x.name !== '0' && x.value !== '' && x.name !== 'prototype' && x.name !== 'length',
+    );
+    array = array.map((x) => {
+      x.name = Input.ToEnvVarFormat(x.name);
+      x.value = `${x.value}`;
+      return x;
+    });
+    return array;
+  }
+
+  private static readBuildParameters(array: any[]) {
+    const keys = Object.keys(CloudRunnerState.buildParams);
+    for (const element of keys) {
+      array.push({
+        name: element,
+        value: CloudRunnerState.buildParams[element],
+      });
+    }
+    array.push({ name: 'buildParameters', value: JSON.stringify(CloudRunnerState.buildParams) });
+    return array;
+  }
+
+  private static readInput(array: any[]) {
+    const input = Object.getOwnPropertyNames(Input);
+    for (const element of input) {
+      if (typeof Input[element] !== 'function' && array.filter((x) => x.name === element).length === 0) {
+        array.push({
+          name: element,
+          value: `${Input[element]}`,
+        });
+      }
+    }
+    return array;
+  }
+
+  private static setupDefaultSecrets() {
+    if (CloudRunnerState.defaultSecrets === undefined)
+      CloudRunnerState.defaultSecrets = ImageEnvironmentFactory.getEnvironmentVariables(
+        CloudRunnerState.buildParams,
+      ).map((x) => {
+        return {
+          ParameterKey: x.name,
+          EnvironmentVariable: x.name,
+          ParameterValue: x.value,
+        };
+      });
+  }
+}
--- a/src/model/cloud-runner/state/cloud-runner-state.ts
+++ b/src/model/cloud-runner/state/cloud-runner-state.ts
@@ -0,0 +1,81 @@
+import path from 'path';
+import { BuildParameters } from '../..';
+import { CloudRunnerProviderInterface } from '../services/cloud-runner-provider-interface';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+
+export class CloudRunnerState {
+  public static CloudRunnerProviderPlatform: CloudRunnerProviderInterface;
+  public static buildParams: BuildParameters;
+  public static defaultSecrets: CloudRunnerSecret[];
+  public static readonly repositoryFolder = 'repo';
+
+  // only the following paths that do not start a path.join with another "Full" suffixed property need to start with an absolute /
+
+  public static get buildPathFull(): string {
+    return path.join(`/`, CloudRunnerState.buildVolumeFolder, CloudRunnerState.buildParams.buildGuid);
+  }
+
+  public static get cacheFolderFull(): string {
+    return path.join(
+      '/',
+      CloudRunnerState.buildVolumeFolder,
+      CloudRunnerState.cacheFolder,
+      CloudRunnerState.branchName,
+    );
+  }
+
+  static setup(buildParameters: BuildParameters) {
+    CloudRunnerState.buildParams = buildParameters;
+  }
+
+  public static get branchName(): string {
+    return CloudRunnerState.buildParams.branch;
+  }
+  public static get builderPathFull(): string {
+    return path.join(CloudRunnerState.buildPathFull, `builder`);
+  }
+
+  public static get repoPathFull(): string {
+    return path.join(CloudRunnerState.buildPathFull, CloudRunnerState.repositoryFolder);
+  }
+
+  public static get projectPathFull(): string {
+    return path.join(CloudRunnerState.repoPathFull, CloudRunnerState.buildParams.projectPath);
+  }
+
+  public static get libraryFolderFull(): string {
+    return path.join(CloudRunnerState.projectPathFull, `Library`);
+  }
+
+  public static get lfsDirectoryFull(): string {
+    return path.join(CloudRunnerState.repoPathFull, `.git`, `lfs`);
+  }
+
+  public static get purgeRemoteCaching(): boolean {
+    return process.env.PURGE_REMOTE_BUILDER_CACHE !== undefined;
+  }
+
+  public static get lfsCacheFolderFull() {
+    return path.join(CloudRunnerState.cacheFolderFull, `lfs`);
+  }
+
+  public static get libraryCacheFolderFull() {
+    return path.join(CloudRunnerState.cacheFolderFull, `Library`);
+  }
+
+  public static get unityBuilderRepoUrl(): string {
+    return `https://${CloudRunnerState.buildParams.githubToken}@github.com/game-ci/unity-builder.git`;
+  }
+
+  public static get targetBuildRepoUrl(): string {
+    return `https://${CloudRunnerState.buildParams.githubToken}@github.com/${CloudRunnerState.buildParams.githubRepo}.git`;
+  }
+
+  public static get buildVolumeFolder() {
+    return 'data';
+  }
+
+  public static get cacheFolder() {
+    return 'cache';
+  }
+}
--- a/src/model/cloud-runner/state/cloud-runner-step-state.ts
+++ b/src/model/cloud-runner/state/cloud-runner-step-state.ts
@@ -0,0 +1,13 @@
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+
+export class CloudRunnerStepState {
+  public image: string;
+  public environment: CloudRunnerEnvironmentVariable[];
+  public secrets: CloudRunnerSecret[];
+  constructor(image: string, environmentVariables: CloudRunnerEnvironmentVariable[], secrets: CloudRunnerSecret[]) {
+    this.image = image;
+    this.environment = environmentVariables;
+    this.secrets = secrets;
+  }
+}
--- a/src/model/cloud-runner/steps/build-step.ts
+++ b/src/model/cloud-runner/steps/build-step.ts
@@ -0,0 +1,77 @@
+import path from 'path';
+import { Input } from '../..';
+import { CloudRunnerBuildCommandProcessor } from '../services/cloud-runner-build-command-process';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import { CloudRunnerStepState } from '../state/cloud-runner-step-state';
+import { StepInterface } from './step-interface';
+
+export class BuildStep implements StepInterface {
+  async run(cloudRunnerStepState: CloudRunnerStepState) {
+    return await BuildStep.BuildStep(
+      cloudRunnerStepState.image,
+      cloudRunnerStepState.environment,
+      cloudRunnerStepState.secrets,
+    );
+  }
+
+  private static async BuildStep(
+    image: string,
+    environmentVariables: CloudRunnerEnvironmentVariable[],
+    secrets: CloudRunnerSecret[],
+  ) {
+    CloudRunnerLogger.logLine(` `);
+    CloudRunnerLogger.logLine('Starting part 2/2 (build unity project)');
+    const hooks = CloudRunnerBuildCommandProcessor.getHooks().filter((x) => x.step.includes(`setup`));
+    return await CloudRunnerState.CloudRunnerProviderPlatform.runTask(
+      CloudRunnerState.buildParams.buildGuid,
+      image,
+      `${hooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
+        export GITHUB_WORKSPACE="${CloudRunnerState.repoPathFull}"
+        cp -r "${path
+          .join(CloudRunnerState.builderPathFull, 'dist', 'default-build-script')
+          .replace(/\\/g, `/`)}" "/UnityBuilderAction"
+        cp -r "${path
+          .join(CloudRunnerState.builderPathFull, 'dist', 'platforms', 'ubuntu', 'entrypoint.sh')
+          .replace(/\\/g, `/`)}" "/entrypoint.sh"
+        cp -r "${path
+          .join(CloudRunnerState.builderPathFull, 'dist', 'platforms', 'ubuntu', 'steps')
+          .replace(/\\/g, `/`)}" "/steps"
+        chmod -R +x "/entrypoint.sh"
+        chmod -R +x "/steps"
+        /entrypoint.sh
+        apt-get update
+        apt-get install -y -q zip tree
+        cd "${CloudRunnerState.libraryFolderFull.replace(/\\/g, `/`)}/.."
+        zip -r "lib-${CloudRunnerState.buildParams.buildGuid}.zip" "Library"
+        mv "lib-${CloudRunnerState.buildParams.buildGuid}.zip" "${CloudRunnerState.cacheFolderFull.replace(
+        /\\/g,
+        `/`,
+      )}/Library"
+        cd "${CloudRunnerState.repoPathFull.replace(/\\/g, `/`)}"
+        ${Input.cloudRunnerTests ? '' : '#'} tree -lh
+        zip -r "build-${CloudRunnerState.buildParams.buildGuid}.zip" "build"
+        ${Input.cloudRunnerTests ? '' : '#'} tree -lh
+        ${Input.cloudRunnerTests ? '' : '#'} tree -lh "${CloudRunnerState.cacheFolderFull.replace(/\\/g, `/`)}"
+        mv "build-${CloudRunnerState.buildParams.buildGuid}.zip" "${CloudRunnerState.cacheFolderFull.replace(
+        /\\/g,
+        `/`,
+      )}"
+        chmod +x ${path.join(CloudRunnerState.builderPathFull, 'dist', `index.js`).replace(/\\/g, `/`)}
+        node ${path
+          .join(CloudRunnerState.builderPathFull, 'dist', `index.js`)
+          .replace(/\\/g, `/`)} -m cache-push "Library" "lib-${
+        CloudRunnerState.buildParams.buildGuid
+      }.zip" "${CloudRunnerState.cacheFolderFull.replace(/\\/g, `/`)}/Library"
+        ${Input.cloudRunnerTests ? '' : '#'} tree -lh "${CloudRunnerState.cacheFolderFull}"
+        ${hooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
+      `,
+      `/${CloudRunnerState.buildVolumeFolder}`,
+      `/${CloudRunnerState.projectPathFull}`,
+      environmentVariables,
+      secrets,
+    );
+  }
+}
--- a/src/model/cloud-runner/steps/setup-step.ts
+++ b/src/model/cloud-runner/steps/setup-step.ts
@@ -0,0 +1,59 @@
+import path from 'path';
+import { Input } from '../..';
+import { CloudRunnerBuildCommandProcessor } from '../services/cloud-runner-build-command-process';
+import CloudRunnerEnvironmentVariable from '../services/cloud-runner-environment-variable';
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import { CloudRunnerStepState } from '../state/cloud-runner-step-state';
+import { StepInterface } from './step-interface';
+
+export class SetupStep implements StepInterface {
+  async run(cloudRunnerStepState: CloudRunnerStepState) {
+    try {
+      return await SetupStep.downloadRepository(
+        cloudRunnerStepState.image,
+        cloudRunnerStepState.environment,
+        cloudRunnerStepState.secrets,
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private static async downloadRepository(
+    image: string,
+    environmentVariables: CloudRunnerEnvironmentVariable[],
+    secrets: CloudRunnerSecret[],
+  ) {
+    try {
+      CloudRunnerLogger.log(` `);
+      CloudRunnerLogger.logLine('Starting step 1/2 (setup game files from repository)');
+      const hooks = CloudRunnerBuildCommandProcessor.getHooks().filter((x) => x.step.includes(`setup`));
+      return await CloudRunnerState.CloudRunnerProviderPlatform.runTask(
+        CloudRunnerState.buildParams.buildGuid,
+        image,
+        `apk update -q
+        apk add git-lfs jq tree zip unzip nodejs -q
+        ${hooks.filter((x) => x.hook.includes(`before`)).map((x) => x.commands) || ' '}
+        export GIT_DISCOVERY_ACROSS_FILESYSTEM=1
+        mkdir -p ${CloudRunnerState.builderPathFull.replace(/\\/g, `/`)}
+        git clone -q -b ${CloudRunnerState.branchName} ${
+          CloudRunnerState.unityBuilderRepoUrl
+        } "${CloudRunnerState.builderPathFull.replace(/\\/g, `/`)}"
+        ${Input.cloudRunnerTests ? '' : '#'} tree ${CloudRunnerState.builderPathFull.replace(/\\/g, `/`)}
+        chmod +x ${path.join(CloudRunnerState.builderPathFull, 'dist', `index.js`).replace(/\\/g, `/`)}
+        node ${path.join(CloudRunnerState.builderPathFull, 'dist', `index.js`).replace(/\\/g, `/`)} -m remote-cli
+        ${hooks.filter((x) => x.hook.includes(`after`)).map((x) => x.commands) || ' '}
+        `,
+        `/${CloudRunnerState.buildVolumeFolder}`,
+        `/${CloudRunnerState.buildVolumeFolder}/`,
+        environmentVariables,
+        secrets,
+      );
+    } catch (error) {
+      CloudRunnerLogger.logLine(`Failed download repository step 1/2`);
+      throw error;
+    }
+  }
+}
--- a/src/model/cloud-runner/steps/step-interface.ts
+++ b/src/model/cloud-runner/steps/step-interface.ts
@@ -0,0 +1,8 @@
+import { CloudRunnerStepState } from '../state/cloud-runner-step-state';
+
+export interface StepInterface {
+  run(
+    // eslint-disable-next-line no-unused-vars
+    cloudRunnerStepState: CloudRunnerStepState,
+  );
+}
--- a/src/model/cloud-runner/workflows/build-automation-workflow.ts
+++ b/src/model/cloud-runner/workflows/build-automation-workflow.ts
@@ -0,0 +1,68 @@
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import { TaskParameterSerializer } from '../services/task-parameter-serializer';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import { CloudRunnerStepState } from '../state/cloud-runner-step-state';
+import { BuildStep } from '../steps/build-step';
+import { SetupStep } from '../steps/setup-step';
+import { CustomWorkflow } from './custom-workflow';
+import { WorkflowInterface } from './workflow-interface';
+import * as core from '@actions/core';
+
+export class BuildAutomationWorkflow implements WorkflowInterface {
+  async run(cloudRunnerStepState: CloudRunnerStepState) {
+    try {
+      return await BuildAutomationWorkflow.standardBuildAutomation(cloudRunnerStepState.image);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private static async standardBuildAutomation(baseImage: any) {
+    try {
+      CloudRunnerLogger.log(`Cloud Runner is running standard build automation`);
+
+      core.startGroup('pre build steps');
+      let output = '';
+      if (CloudRunnerState.buildParams.preBuildSteps !== '') {
+        output += await CustomWorkflow.runCustomJob(CloudRunnerState.buildParams.preBuildSteps);
+      }
+      core.endGroup();
+      CloudRunnerLogger.logWithTime('Configurable pre build step(s) time');
+
+      core.startGroup('setup');
+      output += await new SetupStep().run(
+        new CloudRunnerStepState(
+          'alpine/git',
+          TaskParameterSerializer.readBuildEnvironmentVariables(),
+          CloudRunnerState.defaultSecrets,
+        ),
+      );
+      core.endGroup();
+      CloudRunnerLogger.logWithTime('Download repository step time');
+
+      core.startGroup('build');
+      output += await new BuildStep().run(
+        new CloudRunnerStepState(
+          baseImage,
+          TaskParameterSerializer.readBuildEnvironmentVariables(),
+          CloudRunnerState.defaultSecrets,
+        ),
+      );
+      core.endGroup();
+      CloudRunnerLogger.logWithTime('Build time');
+
+      core.startGroup('post build steps');
+      if (CloudRunnerState.buildParams.postBuildSteps !== '') {
+        output += await CustomWorkflow.runCustomJob(CloudRunnerState.buildParams.postBuildSteps);
+      }
+      core.endGroup();
+      CloudRunnerLogger.logWithTime('Configurable post build step(s) time');
+
+      CloudRunnerLogger.log(`Cloud Runner finished running standard build automation`);
+
+      return output;
+    } catch (error) {
+      throw error;
+    }
+  }
+}
--- a/src/model/cloud-runner/workflows/custom-workflow.ts
+++ b/src/model/cloud-runner/workflows/custom-workflow.ts
@@ -0,0 +1,46 @@
+import CloudRunnerLogger from '../services/cloud-runner-logger';
+import CloudRunnerSecret from '../services/cloud-runner-secret';
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import YAML from 'yaml';
+import { Input } from '../..';
+import { TaskParameterSerializer } from '../services/task-parameter-serializer';
+
+export class CustomWorkflow {
+  public static async runCustomJob(buildSteps) {
+    try {
+      CloudRunnerLogger.log(`Cloud Runner is running in custom job mode`);
+      if (Input.cloudRunnerTests) {
+        CloudRunnerLogger.log(`Parsing build steps: ${buildSteps}`);
+      }
+      try {
+        buildSteps = YAML.parse(buildSteps);
+        let output = '';
+        for (const step of buildSteps) {
+          const stepSecrets: CloudRunnerSecret[] = step.secrets.map((x) => {
+            const secret: CloudRunnerSecret = {
+              ParameterKey: x.name,
+              EnvironmentVariable: Input.ToEnvVarFormat(x.name),
+              ParameterValue: x.value,
+            };
+            return secret;
+          });
+          output += await CloudRunnerState.CloudRunnerProviderPlatform.runTask(
+            CloudRunnerState.buildParams.buildGuid,
+            step['image'],
+            step['commands'],
+            `/${CloudRunnerState.buildVolumeFolder}`,
+            `/${CloudRunnerState.buildVolumeFolder}/`,
+            TaskParameterSerializer.readBuildEnvironmentVariables(),
+            [...CloudRunnerState.defaultSecrets, ...stepSecrets],
+          );
+        }
+        return output;
+      } catch (error) {
+        CloudRunnerLogger.log(`failed to parse a custom job "${buildSteps}"`);
+        throw error;
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+}
--- a/src/model/cloud-runner/workflows/workflow-composition-root.ts
+++ b/src/model/cloud-runner/workflows/workflow-composition-root.ts
@@ -0,0 +1,42 @@
+import { CloudRunnerState } from '../state/cloud-runner-state';
+import { CloudRunnerStepState } from '../state/cloud-runner-step-state';
+import { CustomWorkflow } from './custom-workflow';
+import { WorkflowInterface } from './workflow-interface';
+import { BuildAutomationWorkflow } from './build-automation-workflow';
+import { TaskParameterSerializer } from '../services/task-parameter-serializer';
+import { SetupStep } from '../steps/setup-step';
+
+export class WorkflowCompositionRoot implements WorkflowInterface {
+  async run(cloudRunnerStepState: CloudRunnerStepState) {
+    try {
+      return await WorkflowCompositionRoot.runJob(cloudRunnerStepState.image.toString());
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private static async runJob(baseImage: any) {
+    try {
+      if (CloudRunnerState.buildParams.customJob === `setup`) {
+        return await new SetupStep().run(
+          new CloudRunnerStepState(
+            baseImage,
+            TaskParameterSerializer.readBuildEnvironmentVariables(),
+            CloudRunnerState.defaultSecrets,
+          ),
+        );
+      } else if (CloudRunnerState.buildParams.customJob !== '') {
+        return await CustomWorkflow.runCustomJob(CloudRunnerState.buildParams.customJob);
+      }
+      return await new BuildAutomationWorkflow().run(
+        new CloudRunnerStepState(
+          baseImage,
+          TaskParameterSerializer.readBuildEnvironmentVariables(),
+          CloudRunnerState.defaultSecrets,
+        ),
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+}
--- a/src/model/cloud-runner/workflows/workflow-interface.ts
+++ b/src/model/cloud-runner/workflows/workflow-interface.ts
@@ -0,0 +1,8 @@
+import { CloudRunnerStepState } from '../state/cloud-runner-step-state';
+
+export interface WorkflowInterface {
+  run(
+    // eslint-disable-next-line no-unused-vars
+    cloudRunnerStepState: CloudRunnerStepState,
+  );
+}