@kapeta/local-cluster-service 0.10.1 → 0.11.1

package/dist/esm/src/instanceManager.js

@@ -1,5 +1,6 @@
 import _ from 'lodash';
 import request from 'request';
+import AsyncLock from 'async-lock';
 import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
 import { socketManager } from './socketManager';
@@ -19,6 +20,7 @@ const MIN_TIME_RUNNING = 30000; //If something didnt run for more than 30 secs -
 export class InstanceManager {
     _interval = undefined;
     _instances = [];
+    instanceLocks = new AsyncLock();
     constructor() {
         this._instances = storageService.section('instances', []);
         // We need to wait a bit before running the first check
@@ -50,6 +52,36 @@ export class InstanceManager {
         systemId = normalizeKapetaUri(systemId);
         return this._instances.find((i) => i.systemId === systemId && i.instanceId === instanceId);
     }
+    async exclusive(systemId, instanceId, fn) {
+        systemId = normalizeKapetaUri(systemId);
+        const key = `${systemId}/${instanceId}`;
+        return this.instanceLocks.acquire(key, fn);
+    }
+    async getLogs(systemId, instanceId) {
+        const instance = this.getInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${systemId}/${instanceId} not found`);
+        }
+        switch (instance.type) {
+            case InstanceType.DOCKER:
+                return await containerManager.getLogs(instance);
+            case InstanceType.UNKNOWN:
+                return [{
+                        level: 'INFO',
+                        message: 'Instance is starting...',
+                        time: Date.now(),
+                        source: 'stdout',
+                    }];
+            case InstanceType.LOCAL:
+                return [{
+                        level: 'INFO',
+                        message: 'Instance started outside Kapeta - logs not available...',
+                        time: Date.now(),
+                        source: 'stdout',
+                    }];
+        }
+        return [];
+    }
     async saveInternalInstance(instance) {
         instance.systemId = normalizeKapetaUri(instance.systemId);
         if (instance.ref) {
@@ -80,58 +112,59 @@ export class InstanceManager {
      * which self-registers with the cluster service locally on startup.
      */
     async registerInstanceFromSDK(systemId, instanceId, info) {
-        systemId = normalizeKapetaUri(systemId);
-        let instance = this.getInstance(systemId, instanceId);
-        //Get target address
-        const address = await serviceManager.getProviderAddress(systemId, instanceId, info.portType ?? DEFAULT_HEALTH_PORT_TYPE);
-        const healthUrl = this.getHealthUrl(info, address);
-        if (instance) {
-            if (instance.status === InstanceStatus.STOPPING && instance.desiredStatus === DesiredInstanceStatus.STOP) {
-                //If instance is stopping do not interfere
-                return;
-            }
-            if (info.owner === InstanceOwner.EXTERNAL) {
-                //If instance was started externally - then we want to replace the internal instance with that
-                if (instance.owner === InstanceOwner.INTERNAL &&
-                    (instance.status === InstanceStatus.READY ||
-                        instance.status === InstanceStatus.STARTING ||
-                        instance.status === InstanceStatus.UNHEALTHY)) {
-                    throw new Error(`Instance ${instanceId} is already running`);
+        return this.exclusive(systemId, instanceId, async () => {
+            systemId = normalizeKapetaUri(systemId);
+            let instance = this.getInstance(systemId, instanceId);
+            //Get target address
+            const address = await serviceManager.getProviderAddress(systemId, instanceId, info.portType ?? DEFAULT_HEALTH_PORT_TYPE);
+            const healthUrl = this.getHealthUrl(info, address);
+            if (instance) {
+                if (instance.status === InstanceStatus.STOPPING && instance.desiredStatus === DesiredInstanceStatus.STOP) {
+                    //If instance is stopping do not interfere
+                    return;
                 }
-                instance.desiredStatus = info.desiredStatus;
-                instance.owner = info.owner;
-                instance.internal = undefined;
-                instance.status = InstanceStatus.STARTING;
-                instance.startedAt = Date.now();
-            }
-            instance.pid = info.pid;
-            instance.address = address;
-            if (info.type) {
-                instance.type = info.type;
+                if (info.owner === InstanceOwner.EXTERNAL) {
+                    //If instance was started externally - then we want to replace the internal instance with that
+                    if (instance.owner === InstanceOwner.INTERNAL &&
+                        (instance.status === InstanceStatus.READY ||
+                            instance.status === InstanceStatus.STARTING ||
+                            instance.status === InstanceStatus.UNHEALTHY)) {
+                        throw new Error(`Instance ${instanceId} is already running`);
+                    }
+                    instance.desiredStatus = info.desiredStatus;
+                    instance.owner = info.owner;
+                    instance.status = InstanceStatus.STARTING;
+                    instance.startedAt = Date.now();
+                }
+                instance.pid = info.pid;
+                instance.address = address;
+                if (info.type) {
+                    instance.type = info.type;
+                }
+                if (healthUrl) {
+                    instance.health = healthUrl;
+                }
+                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
             }
-            if (healthUrl) {
-                instance.health = healthUrl;
+            else {
+                //If instance was not found - then we're receiving an externally started instance
+                instance = {
+                    ...info,
+                    systemId,
+                    instanceId,
+                    status: InstanceStatus.STARTING,
+                    startedAt: Date.now(),
+                    desiredStatus: DesiredInstanceStatus.EXTERNAL,
+                    owner: InstanceOwner.EXTERNAL,
+                    health: healthUrl,
+                    address,
+                };
+                this._instances.push(instance);
+                this.emitSystemEvent(systemId, EVENT_INSTANCE_CREATED, instance);
             }
-            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
-        }
-        else {
-            //If instance was not found - then we're receiving an externally started instance
-            instance = {
-                ...info,
-                systemId,
-                instanceId,
-                status: InstanceStatus.STARTING,
-                startedAt: Date.now(),
-                desiredStatus: DesiredInstanceStatus.EXTERNAL,
-                owner: InstanceOwner.EXTERNAL,
-                health: healthUrl,
-                address,
-            };
-            this._instances.push(instance);
-            this.emitSystemEvent(systemId, EVENT_INSTANCE_CREATED, instance);
-        }
-        this.save();
-        return instance;
+            this.save();
+            return instance;
+        });
     }
     getHealthUrl(info, address) {
         let healthUrl = null;
@@ -145,15 +178,17 @@ export class InstanceManager {
         return healthUrl;
     }
     markAsStopped(systemId, instanceId) {
-        systemId = normalizeKapetaUri(systemId);
-        const instance = _.find(this._instances, { systemId, instanceId });
-        if (instance && instance.owner === InstanceOwner.EXTERNAL && instance.status !== InstanceStatus.STOPPED) {
-            instance.status = InstanceStatus.STOPPED;
-            instance.pid = null;
-            instance.health = null;
-            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
-            this.save();
-        }
+        return this.exclusive(systemId, instanceId, async () => {
+            systemId = normalizeKapetaUri(systemId);
+            const instance = _.find(this._instances, { systemId, instanceId });
+            if (instance && instance.owner === InstanceOwner.EXTERNAL && instance.status !== InstanceStatus.STOPPED) {
+                instance.status = InstanceStatus.STOPPED;
+                instance.pid = null;
+                instance.health = null;
+                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                this.save();
+            }
+        });
     }
     async startAllForPlan(systemId) {
         systemId = normalizeKapetaUri(systemId);
@@ -182,54 +217,60 @@ export class InstanceManager {
         return settled.map((p) => (p.status === 'fulfilled' ? p.value : null)).filter((p) => !!p);
     }
     async stop(systemId, instanceId) {
-        systemId = normalizeKapetaUri(systemId);
-        const instance = this.getInstance(systemId, instanceId);
-        if (!instance) {
-            return;
-        }
-        if (instance.status === InstanceStatus.STOPPED) {
-            return;
-        }
-        if (instance.desiredStatus !== DesiredInstanceStatus.EXTERNAL) {
-            instance.desiredStatus = DesiredInstanceStatus.STOP;
-        }
-        instance.status = InstanceStatus.STOPPING;
-        this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
-        console.log('Stopping instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
-        this.save();
-        try {
-            if (instance.type === 'docker') {
-                const containerName = getBlockInstanceContainerName(instance.instanceId);
-                const container = await containerManager.getContainerByName(containerName);
-                if (container) {
-                    try {
-                        await container.stop();
-                        instance.status = InstanceStatus.STOPPED;
-                        this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
-                        this.save();
+        return this.stopInner(systemId, instanceId, true);
+    }
+    async stopInner(systemId, instanceId, changeDesired = false) {
+        return this.exclusive(systemId, instanceId, async () => {
+            systemId = normalizeKapetaUri(systemId);
+            const instance = this.getInstance(systemId, instanceId);
+            if (!instance) {
+                return;
+            }
+            if (instance.status === InstanceStatus.STOPPED) {
+                return;
+            }
+            if (changeDesired &&
+                instance.desiredStatus !== DesiredInstanceStatus.EXTERNAL) {
+                instance.desiredStatus = DesiredInstanceStatus.STOP;
+            }
+            instance.status = InstanceStatus.STOPPING;
+            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+            console.log('Stopping instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
+            this.save();
+            try {
+                if (instance.type === 'docker') {
+                    const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
+                    const container = await containerManager.getContainerByName(containerName);
+                    if (container) {
+                        try {
+                            await container.stop();
+                            instance.status = InstanceStatus.STOPPED;
+                            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                            this.save();
+                        }
+                        catch (e) {
+                            console.error('Failed to stop container', e);
+                        }
                     }
-                    catch (e) {
-                        console.error('Failed to stop container', e);
+                    else {
+                        console.warn('Container not found', containerName);
                     }
+                    return;
                 }
-                else {
-                    console.warn('Container not found', containerName);
+                if (!instance.pid) {
+                    instance.status = InstanceStatus.STOPPED;
+                    this.save();
+                    return;
                 }
-                return;
-            }
-            if (!instance.pid) {
+                process.kill(instance.pid, 'SIGTERM');
                 instance.status = InstanceStatus.STOPPED;
+                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                 this.save();
-                return;
             }
-            process.kill(instance.pid, 'SIGTERM');
-            instance.status = InstanceStatus.STOPPED;
-            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
-            this.save();
-        }
-        catch (e) {
-            console.error('Failed to stop process', e);
-        }
+            catch (e) {
+                console.error('Failed to stop process', e);
+            }
+        });
     }
     async stopAllForPlan(systemId) {
         systemId = normalizeKapetaUri(systemId);
@@ -237,143 +278,111 @@ export class InstanceManager {
         return this.stopInstances(instancesForPlan);
     }
     async start(systemId, instanceId) {
-        systemId = normalizeKapetaUri(systemId);
-        const plan = await assetManager.getPlan(systemId, true);
-        if (!plan) {
-            throw new Error('Plan not found: ' + systemId);
-        }
-        const blockInstance = plan.spec && plan.spec.blocks ? _.find(plan.spec.blocks, { id: instanceId }) : null;
-        if (!blockInstance) {
-            throw new Error('Block instance not found: ' + instanceId);
-        }
-        const blockRef = normalizeKapetaUri(blockInstance.block.ref);
-        const blockAsset = await assetManager.getAsset(blockRef, true);
-        if (!blockAsset) {
-            throw new Error('Block not found: ' + blockRef);
-        }
-        const existingInstance = this.getInstance(systemId, instanceId);
-        if (existingInstance) {
-            if (existingInstance.status === InstanceStatus.READY) {
-                // Instance is already running
-                return existingInstance;
+        return this.exclusive(systemId, instanceId, async () => {
+            systemId = normalizeKapetaUri(systemId);
+            const plan = await assetManager.getPlan(systemId, true);
+            if (!plan) {
+                throw new Error('Plan not found: ' + systemId);
             }
-            if (existingInstance.desiredStatus === DesiredInstanceStatus.RUN &&
-                existingInstance.status === InstanceStatus.STARTING) {
-                // Internal instance is already starting - don't start it again
-                return existingInstance;
+            const blockInstance = plan.spec && plan.spec.blocks ? _.find(plan.spec.blocks, { id: instanceId }) : null;
+            if (!blockInstance) {
+                throw new Error('Block instance not found: ' + instanceId);
             }
-            if (existingInstance.owner === InstanceOwner.EXTERNAL &&
-                existingInstance.status === InstanceStatus.STARTING) {
-                // External instance is already starting - don't start it again
-                return existingInstance;
+            const blockRef = normalizeKapetaUri(blockInstance.block.ref);
+            const blockAsset = await assetManager.getAsset(blockRef, true);
+            if (!blockAsset) {
+                throw new Error('Block not found: ' + blockRef);
             }
-        }
-        let instance = {
-            systemId,
-            instanceId,
-            ref: blockRef,
-            name: blockAsset.data.metadata.name,
-            desiredStatus: DesiredInstanceStatus.RUN,
-            owner: InstanceOwner.INTERNAL,
-            type: InstanceType.UNKNOWN,
-            status: InstanceStatus.STARTING,
-            startedAt: Date.now(),
-        };
-        console.log('Starting instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
-        // Save the instance before starting it, so that we can track the status
-        await this.saveInternalInstance(instance);
-        if (existingInstance) {
-            // Check if the instance is already running - but after we've commmuicated the desired status
-            const currentStatus = await this.requestInstanceStatus(existingInstance);
-            if (currentStatus === InstanceStatus.READY) {
-                // Instance is already running
-                return existingInstance;
-            }
-        }
-        const instanceConfig = await configManager.getConfigForSection(systemId, instanceId);
-        const runner = new BlockInstanceRunner(systemId);
-        const startTime = Date.now();
-        try {
-            const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
-            //emit stdout/stderr via sockets
-            processInfo.output.on('data', (data) => {
-                const payload = {
-                    source: 'stdout',
-                    level: 'INFO',
-                    message: data.toString(),
-                    time: Date.now(),
-                };
-                this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, payload);
-            });
-            processInfo.output.on('exit', (exitCode) => {
-                const timeRunning = Date.now() - startTime;
-                const instance = this.getInstance(systemId, instanceId);
-                if (instance?.status === InstanceStatus.READY) {
-                    //It's already been running
-                    return;
+            const existingInstance = this.getInstance(systemId, instanceId);
+            if (existingInstance) {
+                if (existingInstance.status === InstanceStatus.READY) {
+                    // Instance is already running
+                    return existingInstance;
                 }
-                if (exitCode === 143 || exitCode === 137) {
-                    //Process got SIGTERM (143) or SIGKILL (137)
-                    //TODO: Windows?
-                    return;
+                if (existingInstance.desiredStatus === DesiredInstanceStatus.RUN &&
+                    existingInstance.status === InstanceStatus.STARTING) {
+                    // Internal instance is already starting - don't start it again
+                    return existingInstance;
                 }
-                if (exitCode !== 0 || timeRunning < MIN_TIME_RUNNING) {
-                    const instance = this.getInstance(systemId, instanceId);
-                    if (instance) {
-                        instance.status = InstanceStatus.FAILED;
-                        this.save();
-                    }
-                    this.emitSystemEvent(systemId, EVENT_INSTANCE_EXITED, {
-                        error: 'Failed to start instance',
-                        status: EVENT_INSTANCE_EXITED,
-                        instanceId: blockInstance.id,
-                    });
+                if (existingInstance.owner === InstanceOwner.EXTERNAL &&
+                    existingInstance.status === InstanceStatus.STARTING) {
+                    // External instance is already starting - don't start it again
+                    return existingInstance;
                 }
-            });
-            instance.status = InstanceStatus.READY;
-            return this.saveInternalInstance({
-                ...instance,
-                type: processInfo.type,
-                pid: processInfo.pid ?? -1,
-                health: null,
-                portType: processInfo.portType,
-                status: InstanceStatus.READY,
-                internal: {
-                    logs: processInfo.logs,
-                    output: processInfo.output,
-                },
-            });
-        }
-        catch (e) {
-            console.warn('Failed to start instance', e);
-            const logs = [
-                {
-                    source: 'stdout',
-                    level: 'ERROR',
-                    message: e.message,
-                    time: Date.now(),
-                },
-            ];
-            const out = await this.saveInternalInstance({
-                ...instance,
-                type: InstanceType.LOCAL,
-                pid: null,
-                health: null,
-                portType: DEFAULT_HEALTH_PORT_TYPE,
-                status: InstanceStatus.FAILED,
-            });
-            this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, logs[0]);
-            this.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
-                error: `Failed to start instance: ${e.message}`,
-                status: EVENT_INSTANCE_EXITED,
-                instanceId: blockInstance.id,
-            });
-            return out;
-        }
+            }
+            let instance = {
+                systemId,
+                instanceId,
+                ref: blockRef,
+                name: blockAsset.data.metadata.name,
+                desiredStatus: DesiredInstanceStatus.RUN,
+                owner: InstanceOwner.INTERNAL,
+                type: existingInstance?.type ?? InstanceType.UNKNOWN,
+                status: InstanceStatus.STARTING,
+                startedAt: Date.now(),
+            };
+            console.log('Starting instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
+            // Save the instance before starting it, so that we can track the status
+            await this.saveInternalInstance(instance);
+            if (existingInstance) {
+                // Check if the instance is already running - but after we've commmuicated the desired status
+                const currentStatus = await this.requestInstanceStatus(existingInstance);
+                if (currentStatus === InstanceStatus.READY) {
+                    // Instance is already running
+                    return existingInstance;
+                }
+            }
+            const instanceConfig = await configManager.getConfigForSection(systemId, instanceId);
+            const runner = new BlockInstanceRunner(systemId);
+            const startTime = Date.now();
+            try {
+                const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
+                instance.status = InstanceStatus.READY;
+                return this.saveInternalInstance({
+                    ...instance,
+                    type: processInfo.type,
+                    pid: processInfo.pid ?? -1,
+                    health: null,
+                    portType: processInfo.portType,
+                    status: InstanceStatus.READY,
+                });
+            }
+            catch (e) {
+                console.warn('Failed to start instance', e);
+                const logs = [
+                    {
+                        source: 'stdout',
+                        level: 'ERROR',
+                        message: e.message,
+                        time: Date.now(),
+                    },
+                ];
+                const out = await this.saveInternalInstance({
+                    ...instance,
+                    type: InstanceType.LOCAL,
+                    pid: null,
+                    health: null,
+                    portType: DEFAULT_HEALTH_PORT_TYPE,
+                    status: InstanceStatus.FAILED,
+                });
+                this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, logs[0]);
+                this.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
+                    error: `Failed to start instance: ${e.message}`,
+                    status: EVENT_INSTANCE_EXITED,
+                    instanceId: blockInstance.id,
+                });
+                return out;
+            }
+        });
     }
     async restart(systemId, instanceId) {
         systemId = normalizeKapetaUri(systemId);
-        await this.stop(systemId, instanceId);
+        await this.stopInner(systemId, instanceId);
+        const existingInstance = this.getInstance(systemId, instanceId);
+        if (existingInstance?.desiredStatus === DesiredInstanceStatus.STOP) {
+            // Internal instance was marked as stopped - abort restart
+            return existingInstance;
+        }
         return this.start(systemId, instanceId);
     }
     async stopAll() {
@@ -387,9 +396,7 @@ export class InstanceManager {
     save() {
         try {
             storageService.put('instances', this._instances.map((instance) => {
-                const copy = { ...instance };
-                delete copy.internal;
-                return copy;
+                return { ...instance };
             }));
         }
         catch (e) {
@@ -402,7 +409,7 @@ export class InstanceManager {
         const all = [...this._instances];
         while (all.length > 0) {
             // Check a few instances at a time - docker doesn't like too many concurrent requests
-            const chunk = all.splice(0, 20);
+            const chunk = all.splice(0, 30);
             const promises = chunk.map(async (instance) => {
                 if (!instance.systemId) {
                     return;
@@ -462,7 +469,7 @@ export class InstanceManager {
                     [InstanceStatus.READY, InstanceStatus.STARTING, InstanceStatus.UNHEALTHY].includes(newStatus)) {
                     //If the instance is running but we want it to stop, stop it
                     try {
-                        await this.stop(instance.systemId, instance.instanceId);
+                        await this.stopInner(instance.systemId, instance.instanceId);
                     }
                     catch (e) {
                         console.warn('Failed to stop instance', instance.systemId, instance.instanceId, e);
@@ -491,7 +498,7 @@ export class InstanceManager {
     }
     async getExternalStatus(instance) {
         if (instance.type === InstanceType.DOCKER) {
-            const containerName = getBlockInstanceContainerName(instance.instanceId);
+            const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
             const container = await containerManager.getContainerByName(containerName);
             if (!container) {
                 // If the container doesn't exist, we consider the instance stopped

package/dist/esm/src/instances/routes.js

@@ -62,15 +62,21 @@ router.post('/:systemId/:instanceId/stop', async (req, res) => {
 /**
  * Get logs for instance in a plan
  */
-router.get('/:systemId/:instanceId/logs', (req, res) => {
+router.get('/:systemId/:instanceId/logs', async (req, res) => {
     const instanceInfo = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
     if (!instanceInfo) {
         res.status(404).send({ ok: false });
         return;
     }
-    res.status(202).send({
-        logs: instanceInfo.internal?.logs() ?? [],
-    });
+    try {
+        const logs = await instanceManager.getLogs(req.params.systemId, req.params.instanceId);
+        res.status(200).send({
+            logs,
+        });
+    }
+    catch (e) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
 });
 /**
  * Get public address for instance in a plan if available

package/dist/esm/src/operatorManager.js

@@ -111,13 +111,11 @@ class OperatorManager {
         const operatorData = operator.getData();
         const portTypes = Object.keys(operatorData.ports);
         portTypes.sort();
-        const containerBaseName = 'kapeta-resource';
-        const nameParts = [resourceType.toLowerCase()];
         const ports = {};
         for (let i = 0; i < portTypes.length; i++) {
             const portType = portTypes[i];
             let containerPortInfo = operatorData.ports[portType];
-            const hostPort = await serviceManager.ensureServicePort(resourceType, portType);
+            const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
             if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
                 containerPortInfo = { port: containerPortInfo, type: 'tcp' };
             }
@@ -125,14 +123,18 @@ class OperatorManager {
                 containerPortInfo.type = 'tcp';
             }
             const portId = containerPortInfo.port + '/' + containerPortInfo.type;
-            nameParts.push(portType + '-' + portId + '-' + hostPort);
             ports[portId] = {
                 type: portType,
                 hostPort,
             };
         }
-        const mounts = containerManager.createMounts(resourceType, operatorData.mounts);
-        const containerName = containerBaseName + '-' + md5(nameParts.join('_'));
+        const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
+        const nameParts = [
+            systemId,
+            resourceType.toLowerCase(),
+            version
+        ];
+        const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
         const PortBindings = {};
         const Env = [];
         const Labels = {