@ossy/deployment-tools 0.0.41 → 0.0.43

package/package.json

@@ -1,31 +1,27 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "Collection of scripts and tools to aid deployment of containers and static files to Amazon Web Services through GitHub Actions",
   "type": "module",
-  "types": "dist/index.d.ts" ,
-  "main": "dist/index.js",
+  "main": "src/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "npm run build:public-exports && npm run build:cli",
-    "build:public-exports": "npx --yes @vercel/ncc build src/index.ts --source-map --out dist --license licenses.txt --minify",
-    "build:cli": "npx --yes @vercel/ncc build src/platform-cli.ts --source-map --out bin --license licenses.txt --minify"
+    "build": "",
+    "build:docs": "jsdoc src/index.js"
   },
   "author": "Ossy",
   "license": "ISC",
-  "bin": "bin/index.js",
+  "bin": "src/platform-cli.js",
   "dependencies": {
     "@actions/core": "^1.10.0",
     "@aws-sdk/client-sqs": "^3.186.0",
     "@aws-sdk/client-sts": "^3.188.0",
-    "@aws-sdk/types": "^3.193.0",
     "arg": "^5.0.2",
     "express": "^4.18.1",
     "nanoid": "^4.0.0",
-    "node-fetch": "^3.2.6",
-    "typescript": "^4.8.4"
+    "node-fetch": "^3.2.6"
   },
   "devDependencies": {
-    "@types/node": "^18.11.0"
+    "jsdoc": "^3.6.11"
   }
 }

package/src/{aws-credentials-client.ts → aws-credentials-client.js}

@@ -1,26 +1,25 @@
 import * as core from '@actions/core'
 import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
-import { PlatformConfig } from 'types'
-import { logInfo, logError } from 'log'
+import { logInfo, logError } from './log.js'
 
 export class AwsCredentialsClient {
 
-  static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: PlatformConfig) {
+  static resolveAwsCredentials(platformConfig) {
     // If awsRoleToAssume is present, then we assume we run in a github workflow
     // If awsRoleToAssume is not present, then we assume they are resolved localy by aws-sdk
-    if (!awsRoleToAssume) {
-      logInfo({ message: `[AwsCredentialsClient] No aws role to assume was found, leaving auth logic to @aws-sdk package` })
+    if (!platformConfig.awsRoleToAssume) {
+      logInfo({ message: '[AwsCredentialsClient] No aws role to assume was found, leaving auth logic to @aws-sdk package' })
       return Promise.resolve(undefined)
     }
 
-    const stsClient = new STSClient({ region: awsRegion })
+    const stsClient = new STSClient({ region: platformConfig.awsRegion })
 
     logInfo({ message: '[AwsCredentialsClient] Fetching GitHub ID token' })
     return core.getIDToken('sts.amazonaws.com')
       .then(webIdentityToken => {
-        logInfo({ message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${awsRoleToAssume}` })
+        logInfo({ message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${platformConfig.awsRoleToAssume}` })
         return stsClient.send(new AssumeRoleWithWebIdentityCommand({
-          RoleArn: `arn:aws:iam::${awsAccountId}:role/${awsRoleToAssume}`,
+          RoleArn: `arn:aws:iam::${platformConfig.awsAccountId}:role/${platformConfig.awsRoleToAssume}`,
           RoleSessionName: 'GitHubActions',
           DurationSeconds: 15 * 60,
           WebIdentityToken: webIdentityToken
@@ -33,7 +32,7 @@ export class AwsCredentialsClient {
         SecretAccessKey: responseData.Credentials.SecretAccessKey,
         accessKeyId: responseData.Credentials.AccessKeyId,
         sessionToken: responseData.Credentials.SessionToken,
-        secretAccessKey: responseData.Credentials.SecretAccessKey,
+        secretAccessKey: responseData.Credentials.SecretAccessKey
       }))
       .catch(error => {
         logError({ message: '[AwsCredentialsClient] Could not resolve temporary credentials', error })

package/src/{caddy-client.ts → caddy-client.js}

@@ -1,6 +1,5 @@
 import fetch from 'node-fetch'
-import { logInfo, logError } from './log'
-import { PlatformConfig, ContainerDeploymentRequest } from 'types'
+import { logInfo, logError } from './log.js'
 
 export const Matchers = {
   host: host => ({ host: [host] }),
@@ -20,7 +19,7 @@ const Handlers = {
 
 export class CaddyClient {
 
-  static deploy(platformConfig: PlatformConfig, deploymentRequest: ContainerDeploymentRequest) {
+  static deploy(platformConfig, deploymentRequest) {
 
     const url = `${deploymentRequest.subdomain}.${platformConfig.activeEnvironment}.${platformConfig.domain}`
 
@@ -36,11 +35,11 @@ export class CaddyClient {
         }
       ]))
     })
-    .catch(error => logError({  message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
+      .catch(error => logError({ message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
   }
 
-  static applyDefaultServerConfig(platformConfig: PlatformConfig) {
-    logInfo({  message: '[CaddyClient] Applying default caddy config' })
+  static applyDefaultServerConfig(platformConfig) {
+    logInfo({ message: '[CaddyClient] Applying default caddy config' })
     return fetch('http://localhost:2019/load', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -102,7 +101,7 @@ export class CaddyClient {
         }
       })
     })
-      .catch(error => logError({  message: '[CaddyClient] Could not apply default caddy config', error }))
+      .catch(error => logError({ message: '[CaddyClient] Could not apply default caddy config', error }))
   }
 
 }

package/src/{ci-rest-api.ts → ci-rest-api.js}

@@ -1,10 +1,9 @@
 import express from 'express'
-import { PlatformConfig } from 'types'
-import { logInfo } from './log'
+import { logInfo } from './log.js'
 
 export class CiRestApi {
 
-  static start(platformConfig: PlatformConfig) {
+  static start(platformConfig) {
     const server = express()
 
     server.use(express.json())

package/src/cli-commands/{deploy-handler.ts → deploy-handler.js}

@@ -1,6 +1,6 @@
 import arg from 'arg'
-import { logInfo } from 'log'
-import { PlatformClient } from 'platform-client'
+import { logInfo } from '../log.js'
+import { PlatformClient } from '../platform-client.js'
 
 export const deployHandler = cliArgs => {
   logInfo({ message: 'Running deploy command' })

package/src/cli-commands/{index.ts → index.js}

@@ -1,8 +1,8 @@
-import { logError } from 'log'
-import { startHandler } from './start-handler'
-import { stopHandler } from './stop-handler'
-import { statusHandler } from './status-handler'
-import { deployHandler } from './deploy-handler'
+import { logError } from '../log.js'
+import { startHandler } from './start-handler.js'
+import { stopHandler } from './stop-handler.js'
+import { statusHandler } from './status-handler.js'
+import { deployHandler } from './deploy-handler.js'
 
 export const runCliCommand = ({ name, args }) => {
 

package/src/cli-commands/{start-handler.ts → start-handler.js}

@@ -1,7 +1,7 @@
 import arg from 'arg'
 import { platform } from 'os'
-import { logInfo, logError } from '../log'
-import { PlatformClient } from 'platform-client'
+import { logInfo, logError } from '../log.js'
+import { PlatformClient } from '../platform-client.js'
 
 export const startHandler = cliArgs => {
   logInfo({ message: 'Running start command' })

package/src/cli-commands/{status-handler.ts → status-handler.js}

@@ -1,5 +1,5 @@
 import { exec } from 'child_process'
-import { logInfo } from 'log'
+import { logInfo } from '../log.js'
 
 export const statusHandler = () => {
   logInfo({ message: 'Running status command' })

package/src/cli-commands/{stop-handler.ts → stop-handler.js}

@@ -1,5 +1,5 @@
 import { exec } from 'child_process'
-import { logInfo } from 'log'
+import { logInfo } from '../log.js'
 
 export const stopHandler = () => {
   logInfo({ message: 'Running stop command' })

package/src/{deployment-queue-client.ts → deployment-queue-client.js}

@@ -4,13 +4,12 @@ import {
   DeleteMessageCommand,
   ReceiveMessageCommand
 } from '@aws-sdk/client-sqs'
-import { PlatformConfig, ContainerDeploymentRequest } from 'types'
-import { AwsCredentialsClient } from 'aws-credentials-client'
-import { logInfo, logError, logDebug } from 'log'
+import { AwsCredentialsClient } from './aws-credentials-client.js'
+import { logInfo, logError, logDebug } from './log.js'
 
 export class DeploymentQueueClient {
 
-  static sendDeploymentRequest(platformConfig: PlatformConfig, deploymentRequest: ContainerDeploymentRequest) {
+  static sendDeploymentRequest(platformConfig, deploymentRequest) {
     logInfo({ message: '[DeploymentQueueClient] Starting deployment sequence' })
     return DeploymentQueueClient.createAwsSqsClient(platformConfig)
       .then(sqsClient => {
@@ -30,7 +29,7 @@ export class DeploymentQueueClient {
 
   }
 
-  static pollForDeploymentRequests(platformConfig: PlatformConfig, handleDeploymentRequest: (deploymentRequest: ContainerDeploymentRequest) => Promise<void>) {
+  static pollForDeploymentRequests(platformConfig, handleDeploymentRequest) {
     logInfo({ message: '[DeploymentQueueClient] Starting polling for deployment requests' })
     DeploymentQueueClient.createAwsSqsClient(platformConfig).then(sqsClient => {
       const FIVE_MINUTES = 3000
@@ -61,10 +60,10 @@ export class DeploymentQueueClient {
           .catch(error => logError({ message: '[ContainerManagerServer] Could not handle incoming deployment request', error }))
       }, FIVE_MINUTES)
 
-      })
+    })
   }
 
-  static createAwsSqsClient(platformConfig: PlatformConfig) {
+  static createAwsSqsClient(platformConfig) {
     return AwsCredentialsClient.resolveAwsCredentials(platformConfig)
       .then(awsCredentials => new SQSClient({
         region: platformConfig.awsRegion,

package/src/{docker-client.ts → docker-client.js}

@@ -3,48 +3,47 @@ import fs from 'fs'
 import { nanoid } from 'nanoid'
 import path from 'path'
 import { fileURLToPath } from 'url'
-import { logInfo, logError } from './log'
-import { PlatformConfig, ContainerDeploymentRequest } from 'types'
+import { logInfo, logError } from './log.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
 export class DockerClient {
 
-  static createDockerNetworkForContainerManagerServer(platformConfig: PlatformConfig) {
-    logInfo({  message: '[DockerClient] Creating docker network for comunication between containers' })
+  static createDockerNetworkForContainerManagerServer(platformConfig) {
+    logInfo({ message: '[DockerClient] Creating docker network for comunication between containers' })
     exec(`sudo docker network create ${platformConfig.ciDockerNetworkName}`)
   }
 
-  static stopContainer(deploymentRequest: ContainerDeploymentRequest) {
+  static stopContainer(deploymentRequest) {
     const name = deploymentRequest.image.replaceAll('/', '_')
-    logInfo({  message: `Running docker stop for image with the name of ${name}` })
+    logInfo({ message: `Running docker stop for image with the name of ${name}` })
     return `sudo docker stop ${name} ||`
   }
 
-  static startContainer(platformConfig: PlatformConfig, { image, containerPort, hostPort, registry, env }: ContainerDeploymentRequest) {
+  static startContainer(platformConfig, { image, containerPort, hostPort, registry, env }) {
     const name = image.replaceAll('/', '_')
     const imageUrl = !!registry ? `${registry}/${image}` : image
     const envsAsString = Object.entries(env || {}).reduce((envs, [name, value]) => `${envs} --env ${name}=${value}`, '')
-    logInfo({  message: `Running docker start for image with the name of ${name} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
+    logInfo({ message: `Running docker start for image with the name of ${name} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
     return `sudo docker run -d -p ${hostPort}:${containerPort} --name=${name} --network=${platformConfig.ciDockerNetworkName} --network-alias=${name} --rm ${envsAsString} ${imageUrl}`
   }
 
-  static resolveCredentials({ registry, username, authentication }: ContainerDeploymentRequest) {
+  static resolveCredentials({ registry, username, authentication }) {
     const shouldAuthenticate = username || authentication
 
     if (!shouldAuthenticate) {
-      logInfo({  message: 'No docker credentials provided, assuming image is publicly hosted' })
+      logInfo({ message: 'No docker credentials provided, assuming image is publicly hosted' })
       return ''
     }
 
-    logInfo({  message: `Resolving docker credentials for ${registry}` })
+    logInfo({ message: `Resolving docker credentials for ${registry}` })
     return `sudo docker login ${registry} -u ${username} -p ${authentication}`
   }
 
-  static deploy(platformConfig: PlatformConfig, deploymentRequest: ContainerDeploymentRequest): Promise<void> {
+  static deploy(platformConfig, deploymentRequest) {
     return new Promise(resolve => {
-      logInfo({  message: 'Starting docker deployment sequence' })
+      logInfo({ message: 'Starting docker deployment sequence' })
 
       const dockerCommandScript = `'#!/bin/bash'
 ${DockerClient.stopContainer(deploymentRequest)}
@@ -61,15 +60,15 @@ ${DockerClient.startContainer(platformConfig, deploymentRequest)}`
       const command = exec(`bash ${FilePaths.DeploymentScript}`)
 
       command.stdout.on('data', data => {
-        logInfo({  message: `[DockerClient]: ${data}` })
+        logInfo({ message: `[DockerClient]: ${data}` })
       })
 
       command.stderr.on('data', (data) => {
-        logError({  message: `[DockerClient]: ${data}` })
+        logError({ message: `[DockerClient]: ${data}` })
       })
 
       command.on('close', code => {
-        logInfo({  message: `[DockerClient] command exited with code ${code}` })
+        logInfo({ message: `[DockerClient] command exited with code ${code}` })
         fs.unlinkSync(FilePaths.DeploymentScript)
         resolve()
       })

package/src/index.js

@@ -0,0 +1,3 @@
+export { PlatformClient } from './platform-client.js'
+export { PlatformTemplateService } from './platform-template.js'
+export { PlatformConfigService } from './platform-config.js'

package/src/{log/index.ts → log.js}

@@ -1,18 +1,18 @@
-interface LogInput {
-  type: TypeOfMessage;
-  message: string;
-  data?: any;
-  dataPrefix: string;
-}
+// interface LogInput {
+//   type: TypeOfMessage;
+//   message: string;
+//   data?: any;
+//   dataPrefix: string;
+// }
 
-enum TypeOfMessage {
-  Info = 'INFO',
-  Error = 'ERROR',
-  Debug = 'DEBUG'
+const TypeOfMessage = {
+  Info: 'INFO',
+  Error: 'ERROR',
+  Debug: 'DEBUG'
 }
 
 const log = (...params) => { console.log(...params) }
-const prefixTo = (prefix: string, message: string) => `[${prefix}]${message.startsWith('[') ? '' : ': '}`
+const prefixTo = (prefix, message) => `[${prefix}]${message.startsWith('[') ? '' : ': '}`
 
 export const logInfo = logInput => {
   const messagePrefix = prefixTo(TypeOfMessage.Info, logInput.message)

package/src/{platform-cli.ts → platform-cli.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCliCommand } from './cli-commands/index'
+import { runCliCommand } from './cli-commands/index.js'
 
 //eslint-disable-next-line no-unused-vars
 const [_, __, command, ...restArgs] = process.argv

package/src/{platform-client.ts → platform-client.js}

@@ -1,25 +1,18 @@
 import { resolve } from 'path'
 import { readFileSync } from 'fs'
-import {
-  SupportedEnvironments,
-  ContainerDeploymentRequest,
-  DeploymentTemplate,
-  ContainerDeploymentTemplate,
-  SupportedDeploymentTypes
-} from 'types'
-import { PlatformTemplateService } from 'platform-template'
-import { PlatformConfigService } from 'platform-config'
-import { CaddyClient } from './caddy-client'
-import { DockerClient } from './docker-client'
-import { DeploymentQueueClient } from './deployment-queue-client'
-import { CiRestApi } from './ci-rest-api'
-import { logInfo, logError } from 'log'
-
+import { SupportedDeploymentTypes } from './types.js'
+import { PlatformTemplateService } from './platform-template.js'
+import { PlatformConfigService } from './platform-config.js'
+import { CaddyClient } from './caddy-client.js'
+import { DockerClient } from './docker-client.js'
+import { DeploymentQueueClient } from './deployment-queue-client.js'
+import { CiRestApi } from './ci-rest-api.js'
+import { logError } from './log.js'
 
 // journalctl -u service-name.service
 export class PlatformClient {
 
-  static start(platformTemplatesFilePath: string) {
+  static start(platformTemplatesFilePath) {
     PlatformTemplateService.readFromFile(platformTemplatesFilePath).then(([firstPlatformTemplateFound]) => {
       const platformConfig = PlatformConfigService.from(firstPlatformTemplateFound)
 
@@ -28,7 +21,7 @@ export class PlatformClient {
 
       DeploymentQueueClient.pollForDeploymentRequests(
         platformConfig,
-        (deploymentRequest: ContainerDeploymentRequest) => {
+        deploymentRequest => {
           DockerClient.deploy(platformConfig, deploymentRequest)
           CaddyClient.deploy(platformConfig, deploymentRequest)
           return Promise.resolve()
@@ -36,7 +29,7 @@ export class PlatformClient {
       )
 
     })
-    .catch(error => logError({  message: '[PlatformClient] Could not start the deployment platform', error }))
+      .catch(error => logError({ message: '[PlatformClient] Could not start the deployment platform', error }))
   }
 
   //eslint-disable-next-line max-params
@@ -54,7 +47,7 @@ export class PlatformClient {
 
     const deploymentTemplatesRequest = PlatformClient.getDeploymentTemplates(pathToOssyFile)
 
-    return Promise.all([ platformConfigRequest, deploymentTemplatesRequest ])
+    return Promise.all([platformConfigRequest, deploymentTemplatesRequest])
       .then(([platformConfigs, deploymentTemplates]) => {
         deploymentTemplates.map(deploymentTemplate => {
 
@@ -72,8 +65,8 @@ export class PlatformClient {
             return Promise.reject()
           }
 
-          const deploymentRequest: ContainerDeploymentRequest = {
-            ...deploymentTemplate as ContainerDeploymentTemplate,
+          const deploymentRequest = {
+            ...deploymentTemplate,
             env: PlatformClient.getEnvironmentVariables(targetEnvironment, deploymentTemplate),
             username: username,
             authentication: authentication
@@ -86,12 +79,12 @@ export class PlatformClient {
       .catch(error => logError({ message: '[PlatformClient] Could not send deployment request', error }))
   }
 
-  static getDeploymentTemplates(pathToOssyFile: string): Promise<DeploymentTemplate[]> {
+  static getDeploymentTemplates(pathToOssyFile) {
     const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
     return Promise.resolve(ossyfile.deployments || [])
   }
 
-  static getEnvironmentVariables(targetEnvironment: SupportedEnvironments, deploymentRequest: DeploymentTemplate) {
+  static getEnvironmentVariables(targetEnvironment, deploymentRequest) {
     const envs = deploymentRequest.env || {}
     return {
       ...(envs.shared || {}),

package/src/{platform-config.ts → platform-config.js}

@@ -1,13 +1,11 @@
 import {
-  PlatformConfig,
-  PlatformTemplate,
   SupportedEnvironments,
   SupportedRegions
-} from 'types'
+} from './types.js'
 
 export class PlatformConfigService {
 
-  static from(template: PlatformTemplate): PlatformConfig {
+  static from(template) {
 
     const withDefaults = {
       platformName: SupportedEnvironments.LOCAL,

package/src/platform-template.js

@@ -0,0 +1,63 @@
+import { resolve } from 'path'
+import { readFileSync } from 'fs'
+import { logError, logInfo } from './log.js'
+// @param {number} [foo=1]
+
+/**
+ * Platform template definition
+ * @typedef {Object} PlatformTemplate
+ * @property {string} platformName - Name of platform
+ * @property {string} domain - example.com
+ * @property {string[]} supportedDeploymentTypes - container
+ * @property {string[]} supportedEnvironments - qa
+ * @property {string} awsAccountId - Aws account id
+ * @property {string} awsRegion - ?
+ * @property {string} awsKeyPairName - ?
+ * @property {string} awsRoleToAssume - ?
+ * @property {string} awsDeploymentSqsArn - ?
+ * @property {string} ciSubDomain - ?
+ * @property {string} ciInternalServerPort- ? | number;
+ * @property {string} ciServerName - ?
+ * @property {string} ciDockerNetworkName - ?
+ */
+export class PlatformTemplateService {
+
+  /**
+   * Reads the json file that holds the platform templates
+   *
+   * @param {string} path - File path to platform templates json
+   * @return @Async {PlatformTemplate[]} - List of platform templates
+   *
+   * @example
+   *     const platformTemplate = PlatformTemplateService.readFromFile('./platforms.json')
+   */
+  static readFromFile(path) {
+
+    if (!path) {
+      logError({ message: '[PlatformTemplateService] No path provided' })
+      return Promise.reject()
+    }
+
+    const fileData = readFileSync(resolve(path), 'utf8')
+
+    if (!fileData && typeof fileData !== 'string') {
+      logError({ message: `[PlatformTemplateService] Could not find a deployment platform at ${path}` })
+      return Promise.reject()
+    }
+
+    let potentialTemplates = JSON.parse(fileData)
+
+    if (!Array.isArray(potentialTemplates)) {
+      potentialTemplates = [potentialTemplates]
+    }
+
+    const templates = potentialTemplates.map(PlatformTemplateService.fakeValidateTemplate)
+    logInfo({ message: `[PlatformTemplateService]: Found platforms [${templates.map(x => x.platformName).join(', ')}]` })
+    return Promise.resolve(templates)
+  }
+
+  static fakeValidateTemplate(obj) {
+    // todo: implement real one
+    return obj
+  }
+}

package/src/types.js

@@ -0,0 +1,65 @@
+// export interface PlatformTemplate {
+//   platformName: string;
+//   domain: string;
+//   supportedDeploymentTypes: SupportedDeploymentTypes[];
+//   supportedEnvironments: SupportedEnvironments[];
+//   awsRegion?: string;
+//   awsAccountId: string;
+//   awsKeyPairName?: string;
+//   awsRoleToAssume?: string;
+//   awsDeploymentSqsArn?: string;
+//   ciSubDomain?: string;
+//   ciInternalServerPort?: string | number;
+//   ciServerName?: string;
+//   ciDockerNetworkName?: string;
+// }
+//
+// export interface PlatformConfig extends Required<Omit<PlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
+//   activeEnvironment: SupportedEnvironments;
+//   awsRoleToAssume?: string;
+//   awsKeyPairName?: string;
+// }
+
+export const SupportedRegions = {
+  North: 'eu-north-1'
+}
+
+export const SupportedEnvironments = {
+  LOCAL: 'local',
+  QA: 'qa',
+  TEST: 'test',
+  DEMO: 'demo',
+  PROD: 'prod'
+}
+
+export const SupportedDeploymentTypes = {
+  Container: 'CONTAINER'
+  // Static = 'STATIC'
+}
+
+// export interface DeploymentTemplate {
+//   type: SupportedDeploymentTypes;
+//   targetDeploymentPlatform: string;
+//   subdomain?: string;
+//   env?: {
+//     shared?: { [name: string]: string | number };
+//     prod?: { [name: string]: string | number };
+//     test?: { [name: string]: string | number };
+//     qa?: { [name: string]: string | number };
+//   }
+// }
+//
+// export interface ContainerDeploymentTemplate extends DeploymentTemplate {
+//   type: SupportedDeploymentTypes.Container;
+//   dockerFile: string;
+//   dockerContext: string;
+//   image: string;
+//   hostPort: number;
+//   containerPort: number;
+//   registry: string;
+// }
+
+// export interface ContainerDeploymentRequest extends ContainerDeploymentTemplate {
+//   authentication?: string;
+//   username?: string;
+// }