@kapeta/local-cluster-service 0.10.0 → 0.10.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.10.1](https://github.com/kapetacom/local-cluster-service/compare/v0.10.0...v0.10.1) (2023-07-27)
+
+
+### Bug Fixes
+
+* Include port bindings for non-local containers ([#51](https://github.com/kapetacom/local-cluster-service/issues/51)) ([64fd440](https://github.com/kapetacom/local-cluster-service/commit/64fd4409ea9e2dda8e2438d0ec85a8f5a2092b1e))
+
 # [0.10.0](https://github.com/kapetacom/local-cluster-service/compare/v0.9.1...v0.10.0) (2023-07-26)
 
 

package/dist/cjs/src/utils/BlockInstanceRunner.d.ts

@@ -14,8 +14,6 @@ export declare class BlockInstanceRunner {
      * Starts local process
      */
     private _startLocalProcess;
-    private ensureContainer;
-    private _handleContainer;
     private _startDockerProcess;
     /**
      *
@@ -27,4 +25,7 @@ export declare class BlockInstanceRunner {
      * @private
      */
     _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
+    private getDockerPortBindings;
+    private ensureContainer;
+    private _handleContainer;
 }

package/dist/cjs/src/utils/BlockInstanceRunner.js

@@ -100,7 +100,7 @@ class BlockInstanceRunner {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
             else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
             }
             if (portTypes.length > 0) {
                 processInfo.portType = portTypes[0];
@@ -138,26 +138,7 @@ class BlockInstanceRunner {
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
-        const bindHost = (0, utils_1.getBindHost)();
-        const ExposedPorts = {};
-        const addonEnv = {};
-        const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion);
-        let port = 80;
-        const promises = portTypes.map(async (portType) => {
-            const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
-            const dockerPort = `${thisPort}/tcp`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-        });
-        await Promise.all(promises);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -190,73 +171,7 @@ class BlockInstanceRunner {
             ...dockerOpts,
         });
     }
-    async ensureContainer(opts) {
-        const logs = new LogData_1.LogData();
-        const container = await containerManager_1.containerManager.ensureContainer(opts);
-        try {
-            if (opts.HealthCheck) {
-                await containerManager_1.containerManager.waitForHealthy(container);
-            }
-            else {
-                await containerManager_1.containerManager.waitForReady(container);
-            }
-        }
-        catch (e) {
-            logs.addLog(e.message, 'ERROR');
-        }
-        return this._handleContainer(container, logs);
-    }
-    async _handleContainer(container, logs, deleteOnExit = false) {
-        let localContainer = container;
-        const logStream = (await container.logs({
-            follow: true,
-            stdout: true,
-            stderr: true,
-            tail: LogData_1.LogData.MAX_LINES,
-        }));
-        const outputEvents = new events_1.default();
-        logStream.on('data', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-        logStream.on('error', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-        logStream.on('close', async () => {
-            const status = await container.status();
-            const data = status.data;
-            if (deleteOnExit) {
-                try {
-                    await containerManager_1.containerManager.remove(container);
-                }
-                catch (e) { }
-            }
-            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
-        });
-        return {
-            type: types_1.InstanceType.DOCKER,
-            pid: container.id,
-            output: outputEvents,
-            stop: async () => {
-                if (!localContainer) {
-                    return;
-                }
-                try {
-                    await localContainer.stop();
-                    if (deleteOnExit) {
-                        await containerManager_1.containerManager.remove(localContainer);
-                    }
-                }
-                catch (e) { }
-                localContainer = null;
-            },
-            logs: () => {
-                return logs.getLogs();
-            },
-        };
-    }
-    async _startDockerProcess(blockInstance, blockInfo, env) {
+    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
         const { versionFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
         const versionYml = versionFile;
         if (!node_fs_1.default.existsSync(versionYml)) {
@@ -270,23 +185,28 @@ class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
         const containerName = (0, utils_1.getBlockInstanceContainerName)(blockInstance.id);
-        const logs = new LogData_1.LogData();
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
+            ExposedPorts,
             Labels: {
                 instance: blockInstance.id,
             },
             Env: [
                 ...DOCKER_ENV_VARS,
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
-                ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv
+                }).map(([key, value]) => `${key}=${value}`),
             ],
             HostConfig: {
                 Binds: [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`],
+                PortBindings,
             },
         });
     }
@@ -379,5 +299,94 @@ class BlockInstanceRunner {
         }
         return out;
     }
+    async getDockerPortBindings(blockInstance, assetVersion) {
+        const bindHost = (0, utils_1.getBindHost)();
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        const portTypes = getProviderPorts(assetVersion);
+        let port = 80;
+        const promises = portTypes.map(async (portType) => {
+            const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
+            const dockerPort = `${thisPort}/tcp`;
+            ExposedPorts[dockerPort] = {};
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
+            PortBindings[dockerPort] = [
+                {
+                    HostIp: bindHost,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+        await Promise.all(promises);
+        return { PortBindings, ExposedPorts, addonEnv };
+    }
+    async ensureContainer(opts) {
+        const logs = new LogData_1.LogData();
+        const container = await containerManager_1.containerManager.ensureContainer(opts);
+        try {
+            if (opts.HealthCheck) {
+                await containerManager_1.containerManager.waitForHealthy(container);
+            }
+            else {
+                await containerManager_1.containerManager.waitForReady(container);
+            }
+        }
+        catch (e) {
+            logs.addLog(e.message, 'ERROR');
+        }
+        return this._handleContainer(container, logs);
+    }
+    async _handleContainer(container, logs, deleteOnExit = false) {
+        let localContainer = container;
+        const logStream = (await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            tail: LogData_1.LogData.MAX_LINES,
+        }));
+        const outputEvents = new events_1.default();
+        logStream.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+        logStream.on('error', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+        logStream.on('close', async () => {
+            const status = await container.status();
+            const data = status.data;
+            if (deleteOnExit) {
+                try {
+                    await containerManager_1.containerManager.remove(container);
+                }
+                catch (e) { }
+            }
+            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
+        });
+        return {
+            type: types_1.InstanceType.DOCKER,
+            pid: container.id,
+            output: outputEvents,
+            stop: async () => {
+                if (!localContainer) {
+                    return;
+                }
+                try {
+                    await localContainer.stop();
+                    if (deleteOnExit) {
+                        await containerManager_1.containerManager.remove(localContainer);
+                    }
+                }
+                catch (e) { }
+                localContainer = null;
+            },
+            logs: () => {
+                return logs.getLogs();
+            },
+        };
+    }
 }
 exports.BlockInstanceRunner = BlockInstanceRunner;

package/dist/esm/src/utils/BlockInstanceRunner.d.ts

@@ -14,8 +14,6 @@ export declare class BlockInstanceRunner {
      * Starts local process
      */
     private _startLocalProcess;
-    private ensureContainer;
-    private _handleContainer;
     private _startDockerProcess;
     /**
      *
@@ -27,4 +25,7 @@ export declare class BlockInstanceRunner {
      * @private
      */
     _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
+    private getDockerPortBindings;
+    private ensureContainer;
+    private _handleContainer;
 }

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -94,7 +94,7 @@ export class BlockInstanceRunner {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
             else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
             }
             if (portTypes.length > 0) {
                 processInfo.portType = portTypes[0];
@@ -132,26 +132,7 @@ export class BlockInstanceRunner {
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
-        const bindHost = getBindHost();
-        const ExposedPorts = {};
-        const addonEnv = {};
-        const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion);
-        let port = 80;
-        const promises = portTypes.map(async (portType) => {
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
-            const dockerPort = `${thisPort}/tcp`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-        });
-        await Promise.all(promises);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -184,73 +165,7 @@ export class BlockInstanceRunner {
             ...dockerOpts,
         });
     }
-    async ensureContainer(opts) {
-        const logs = new LogData();
-        const container = await containerManager.ensureContainer(opts);
-        try {
-            if (opts.HealthCheck) {
-                await containerManager.waitForHealthy(container);
-            }
-            else {
-                await containerManager.waitForReady(container);
-            }
-        }
-        catch (e) {
-            logs.addLog(e.message, 'ERROR');
-        }
-        return this._handleContainer(container, logs);
-    }
-    async _handleContainer(container, logs, deleteOnExit = false) {
-        let localContainer = container;
-        const logStream = (await container.logs({
-            follow: true,
-            stdout: true,
-            stderr: true,
-            tail: LogData.MAX_LINES,
-        }));
-        const outputEvents = new EventEmitter();
-        logStream.on('data', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-        logStream.on('error', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-        logStream.on('close', async () => {
-            const status = await container.status();
-            const data = status.data;
-            if (deleteOnExit) {
-                try {
-                    await containerManager.remove(container);
-                }
-                catch (e) { }
-            }
-            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
-        });
-        return {
-            type: InstanceType.DOCKER,
-            pid: container.id,
-            output: outputEvents,
-            stop: async () => {
-                if (!localContainer) {
-                    return;
-                }
-                try {
-                    await localContainer.stop();
-                    if (deleteOnExit) {
-                        await containerManager.remove(localContainer);
-                    }
-                }
-                catch (e) { }
-                localContainer = null;
-            },
-            logs: () => {
-                return logs.getLogs();
-            },
-        };
-    }
-    async _startDockerProcess(blockInstance, blockInfo, env) {
+    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
         const versionYml = versionFile;
         if (!FS.existsSync(versionYml)) {
@@ -264,23 +179,28 @@ export class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
         const containerName = getBlockInstanceContainerName(blockInstance.id);
-        const logs = new LogData();
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
         return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
+            ExposedPorts,
             Labels: {
                 instance: blockInstance.id,
             },
             Env: [
                 ...DOCKER_ENV_VARS,
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
-                ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv
+                }).map(([key, value]) => `${key}=${value}`),
             ],
             HostConfig: {
                 Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
+                PortBindings,
             },
         });
     }
@@ -373,4 +293,93 @@ export class BlockInstanceRunner {
         }
         return out;
     }
+    async getDockerPortBindings(blockInstance, assetVersion) {
+        const bindHost = getBindHost();
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        const portTypes = getProviderPorts(assetVersion);
+        let port = 80;
+        const promises = portTypes.map(async (portType) => {
+            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
+            const dockerPort = `${thisPort}/tcp`;
+            ExposedPorts[dockerPort] = {};
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
+            PortBindings[dockerPort] = [
+                {
+                    HostIp: bindHost,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+        await Promise.all(promises);
+        return { PortBindings, ExposedPorts, addonEnv };
+    }
+    async ensureContainer(opts) {
+        const logs = new LogData();
+        const container = await containerManager.ensureContainer(opts);
+        try {
+            if (opts.HealthCheck) {
+                await containerManager.waitForHealthy(container);
+            }
+            else {
+                await containerManager.waitForReady(container);
+            }
+        }
+        catch (e) {
+            logs.addLog(e.message, 'ERROR');
+        }
+        return this._handleContainer(container, logs);
+    }
+    async _handleContainer(container, logs, deleteOnExit = false) {
+        let localContainer = container;
+        const logStream = (await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            tail: LogData.MAX_LINES,
+        }));
+        const outputEvents = new EventEmitter();
+        logStream.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+        logStream.on('error', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+        logStream.on('close', async () => {
+            const status = await container.status();
+            const data = status.data;
+            if (deleteOnExit) {
+                try {
+                    await containerManager.remove(container);
+                }
+                catch (e) { }
+            }
+            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
+        });
+        return {
+            type: InstanceType.DOCKER,
+            pid: container.id,
+            output: outputEvents,
+            stop: async () => {
+                if (!localContainer) {
+                    return;
+                }
+                try {
+                    await localContainer.stop();
+                    if (deleteOnExit) {
+                        await containerManager.remove(localContainer);
+                    }
+                }
+                catch (e) { }
+                localContainer = null;
+            },
+            logs: () => {
+                return logs.getLogs();
+            },
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.10.0",
+    "version": "0.10.1",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/utils/BlockInstanceRunner.ts

@@ -117,7 +117,7 @@ export class BlockInstanceRunner {
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             } else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
             }
 
             if (portTypes.length > 0) {
@@ -170,36 +170,16 @@ export class BlockInstanceRunner {
         }
 
         const containerName = getBlockInstanceContainerName(blockInstance.id);
-
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
 
-        const bindHost = getBindHost();
-
-        const ExposedPorts: AnyMap = {};
-        const addonEnv: StringMap = {};
-        const PortBindings: AnyMap = {};
-
-        const portTypes = getProviderPorts(assetVersion);
-        let port = 80;
-        const promises = portTypes.map(async (portType) => {
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
-            const dockerPort = `${thisPort}/tcp`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
-
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-        });
-
-        await Promise.all(promises);
+        const {
+            PortBindings,
+            ExposedPorts,
+            addonEnv
+        } = await this.getDockerPortBindings(blockInstance, assetVersion);
 
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
@@ -235,83 +215,7 @@ export class BlockInstanceRunner {
         });
     }
 
-    private async ensureContainer(opts: any) {
-        const logs = new LogData();
-
-        const container = await containerManager.ensureContainer(opts);
-
-        try {
-            if (opts.HealthCheck) {
-                await containerManager.waitForHealthy(container);
-            } else {
-                await containerManager.waitForReady(container);
-            }
-        } catch (e: any) {
-            logs.addLog(e.message, 'ERROR');
-        }
-
-        return this._handleContainer(container, logs);
-    }
-
-    private async _handleContainer(
-        container: Container,
-        logs: LogData,
-        deleteOnExit: boolean = false
-    ): Promise<ProcessInfo> {
-        let localContainer: Container | null = container;
-        const logStream = (await container.logs({
-            follow: true,
-            stdout: true,
-            stderr: true,
-            tail: LogData.MAX_LINES,
-        })) as EventEmitter;
-
-        const outputEvents = new EventEmitter();
-        logStream.on('data', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-
-        logStream.on('error', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-
-        logStream.on('close', async () => {
-            const status = await container.status();
-            const data = status.data as any;
-            if (deleteOnExit) {
-                try {
-                    await containerManager.remove(container);
-                } catch (e: any) {}
-            }
-            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
-        });
-
-        return {
-            type: InstanceType.DOCKER,
-            pid: container.id,
-            output: outputEvents,
-            stop: async () => {
-                if (!localContainer) {
-                    return;
-                }
-
-                try {
-                    await localContainer.stop();
-                    if (deleteOnExit) {
-                        await containerManager.remove(localContainer);
-                    }
-                } catch (e) {}
-                localContainer = null;
-            },
-            logs: () => {
-                return logs.getLogs();
-            },
-        };
-    }
-
-    private async _startDockerProcess(blockInstance: BlockProcessParams, blockInfo: KapetaURI, env: StringMap) {
+    private async _startDockerProcess(blockInstance: BlockProcessParams, blockInfo: KapetaURI, env: StringMap, assetVersion: DefinitionInfo) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(
             blockInfo.handle,
             blockInfo.name,
@@ -333,8 +237,13 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
 
+        const {
+            PortBindings,
+            ExposedPorts,
+            addonEnv
+        } = await this.getDockerPortBindings(blockInstance, assetVersion);
+
         const containerName = getBlockInstanceContainerName(blockInstance.id);
-        const logs = new LogData();
 
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
@@ -342,16 +251,22 @@ export class BlockInstanceRunner {
         return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
+            ExposedPorts,
             Labels: {
                 instance: blockInstance.id,
             },
             Env: [
                 ...DOCKER_ENV_VARS,
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
-                ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv
+                }).map(([key, value]) => `${key}=${value}`),
+
             ],
             HostConfig: {
                 Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
+                PortBindings,
             },
         });
     }
@@ -471,4 +386,110 @@ export class BlockInstanceRunner {
 
         return out;
     }
+
+
+    private async getDockerPortBindings(blockInstance: BlockProcessParams, assetVersion: DefinitionInfo) {
+        const bindHost = getBindHost();
+        const ExposedPorts: AnyMap = {};
+        const addonEnv: StringMap = {};
+        const PortBindings: AnyMap = {};
+
+        const portTypes = getProviderPorts(assetVersion);
+        let port = 80;
+        const promises = portTypes.map(async (portType) => {
+            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
+            const dockerPort = `${thisPort}/tcp`;
+            ExposedPorts[dockerPort] = {};
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
+
+            PortBindings[dockerPort] = [
+                {
+                    HostIp: bindHost,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+
+
+        await Promise.all(promises);
+
+        return {PortBindings,ExposedPorts, addonEnv};
+    }
+
+    private async ensureContainer(opts: any) {
+        const logs = new LogData();
+
+        const container = await containerManager.ensureContainer(opts);
+
+        try {
+            if (opts.HealthCheck) {
+                await containerManager.waitForHealthy(container);
+            } else {
+                await containerManager.waitForReady(container);
+            }
+        } catch (e: any) {
+            logs.addLog(e.message, 'ERROR');
+        }
+
+        return this._handleContainer(container, logs);
+    }
+
+    private async _handleContainer(
+        container: Container,
+        logs: LogData,
+        deleteOnExit: boolean = false
+    ): Promise<ProcessInfo> {
+        let localContainer: Container | null = container;
+        const logStream = (await container.logs({
+            follow: true,
+            stdout: true,
+            stderr: true,
+            tail: LogData.MAX_LINES,
+        })) as EventEmitter;
+
+        const outputEvents = new EventEmitter();
+        logStream.on('data', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+
+        logStream.on('error', (data) => {
+            logs.addLog(data.toString());
+            outputEvents.emit('data', data);
+        });
+
+        logStream.on('close', async () => {
+            const status = await container.status();
+            const data = status.data as any;
+            if (deleteOnExit) {
+                try {
+                    await containerManager.remove(container);
+                } catch (e: any) {}
+            }
+            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
+        });
+
+        return {
+            type: InstanceType.DOCKER,
+            pid: container.id,
+            output: outputEvents,
+            stop: async () => {
+                if (!localContainer) {
+                    return;
+                }
+
+                try {
+                    await localContainer.stop();
+                    if (deleteOnExit) {
+                        await containerManager.remove(localContainer);
+                    }
+                } catch (e) {}
+                localContainer = null;
+            },
+            logs: () => {
+                return logs.getLogs();
+            },
+        };
+    }
 }