diff --git a/app/modules/Events/Domain/Events/EventWasReceived.php b/app/modules/Events/Domain/Events/EventWasReceived.php
index 1e56f60e..e745237a 100644
--- a/app/modules/Events/Domain/Events/EventWasReceived.php
+++ b/app/modules/Events/Domain/Events/EventWasReceived.php
@@ -22,7 +22,7 @@ public function __construct(
     public function jsonSerialize(): array
     {
         return [
-            'projectId' => $this->projectId,
+            'project_id' => $this->projectId,
             'uuid' => (string)$this->uuid,
             'type' => $this->type,
             'payload' => $this->payload,
diff --git a/app/modules/SshTunnel/Application/CommandBuilder.php b/app/modules/SshTunnel/Application/CommandBuilder.php
new file mode 100644
index 00000000..2f744b6a
--- /dev/null
+++ b/app/modules/SshTunnel/Application/CommandBuilder.php
@@ -0,0 +1,130 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Application;
+
+use Spiral\Files\FilesInterface;
+use Webmozart\Assert\Assert;
+
+final class CommandBuilder
+{
+    private const SSH_SERVER_ALIVE_INTERVAL = 15;
+
+    private int $sshPort = 22;
+    private string $user = 'root';
+    private ?string $sshHost = null;
+    private ?string $password = null;
+    private ?string $privateKey = null;
+    private array $forwardPorts = [];
+    private bool $compression = false;
+
+    public function __construct(
+        private readonly FilesInterface $files,
+    ) {
+    }
+
+    public function host(string $host): self
+    {
+        Assert::notEmpty($host, 'Host cannot be empty');
+        $this->sshHost = $host;
+
+        return $this;
+    }
+
+    public function user(string $user): self
+    {
+        Assert::notEmpty($user, 'User cannot be empty');
+        $this->user = $user;
+
+        return $this;
+    }
+
+    public function sshPort(int $port): self
+    {
+        Assert::greaterThanEq($port, 1, 'SSH port cannot be less than 1');
+        Assert::lessThan($port, 65536, 'SSH port cannot be greater than 65535');
+
+        $this->sshPort = $port;
+
+        return $this;
+    }
+
+    public function password(string $password): self
+    {
+        Assert::notEmpty($password, 'Password cannot be empty');
+        $this->password = $password;
+
+        return $this;
+    }
+
+    public function privateKey(string $privateKey): self
+    {
+        Assert::notEmpty($privateKey, 'Private key cannot be empty');
+        $this->privateKey = $this->writeKeyToFile($privateKey);
+        \usleep(500_000);
+
+        return $this;
+    }
+
+    public function forwardPort(int $localPort, int $remotePort): self
+    {
+        $this->forwardPorts[] = [
+            'localPort' => $localPort,
+            'remotePort' => $remotePort,
+        ];
+
+        return $this;
+    }
+
+    public function build(): array
+    {
+        Assert::true($this->password !== null || $this->privateKey !== null, 'Password or private key must be set');
+
+        $cmd = [
+            'ssh',
+            '-p',
+            $this->sshPort,
+            ...\array_map(
+                callback: fn(array $port) => \sprintf(
+                    '-R %d:%s:%d',
+                    $port['localPort'],
+                    'localhost',
+                    $port['remotePort'],
+                ),
+                array: $this->forwardPorts,
+            ),
+            '-i',
+            $this->privateKey,
+            '-N',
+            '-o',
+            \sprintf('ServerAliveInterval=%d', self::SSH_SERVER_ALIVE_INTERVAL),
+            '-o',
+            'ExitOnForwardFailure=yes',
+            '-o',
+            'StrictHostKeyChecking=no',
+            \sprintf('%s@%s', $this->user, $this->sshHost),
+        ];
+
+        if ($this->compression) {
+            $cmd[] = '-C';
+        }
+
+        return $cmd;
+    }
+
+    private function writeKeyToFile(string $key): string
+    {
+        $fileName = (string)\tempnam('/tmp/', 'ssh-key-');
+
+        $this->files->append($fileName, $key);
+        $this->files->setPermissions($fileName, 0400);
+
+        return (string)\realpath($fileName);
+    }
+
+    public function getPrivateKey(): ?string
+    {
+        return $this->privateKey;
+    }
+}
diff --git a/app/modules/SshTunnel/Application/SshTunnelBootloader.php b/app/modules/SshTunnel/Application/SshTunnelBootloader.php
new file mode 100644
index 00000000..7ac4ecf5
--- /dev/null
+++ b/app/modules/SshTunnel/Application/SshTunnelBootloader.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Application;
+
+use Spiral\Boot\Bootloader\Bootloader;
+
+final class SshTunnelBootloader extends Bootloader
+{
+    public function defineSingletons(): array
+    {
+        return [
+
+        ];
+    }
+}
diff --git a/app/modules/SshTunnel/Application/SshTunnelService.php b/app/modules/SshTunnel/Application/SshTunnelService.php
new file mode 100644
index 00000000..bb16d353
--- /dev/null
+++ b/app/modules/SshTunnel/Application/SshTunnelService.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Application;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Spiral\Exceptions\ExceptionReporterInterface;
+use Spiral\RoadRunner\Services\Exception\ServiceException;
+use Spiral\RoadRunner\Services\Manager;
+
+final class SshTunnelService
+{
+    private const NAME_PREFIX = 'ssh-';
+
+    public function __construct(
+        private readonly Manager $manager,
+        private readonly ExceptionReporterInterface $reporter,
+    ) {
+    }
+
+    /**
+     * Check if the tunnel is connected.
+     */
+    public function isRunning(Uuid $connectionUuid): bool
+    {
+        return $this->manager->statuses($this->getTunnelName($connectionUuid)) !== [];
+    }
+
+    /**
+     * Get the list of all connected tunnels.
+     */
+    public function list(): array
+    {
+        return \array_map(
+            callback: fn(string $name) => $this->manager->statuses($name),
+            array: \array_filter(
+                $this->manager->list(),
+                static fn(string $service) => \str_starts_with($service, self::NAME_PREFIX),
+            ),
+        );
+    }
+
+    /**
+     * Connect to the remote server.
+     */
+    public function connect(Uuid $connectionUuid): void
+    {
+        $this->manager->create(
+            name: $this->getTunnelName($connectionUuid),
+            command: \sprintf('php app.php ssh:tunnel %s', $connectionUuid),
+            processNum: 1,
+            remainAfterExit: true,
+            serviceNameInLogs: true,
+        );
+    }
+
+    /**
+     * Disconnect from the remote server.
+     */
+    public function disconnect(Uuid $connectionUuid): void
+    {
+        try {
+            $this->manager->terminate($this->getTunnelName($connectionUuid));
+        } catch (ServiceException $e) {
+            $this->reporter->report($e);
+        }
+    }
+
+    private function getTunnelName(Uuid $connectionUuid): string
+    {
+        return self::NAME_PREFIX . $connectionUuid;
+    }
+}
diff --git a/app/modules/SshTunnel/Domain/Connection.php b/app/modules/SshTunnel/Domain/Connection.php
new file mode 100644
index 00000000..39d58563
--- /dev/null
+++ b/app/modules/SshTunnel/Domain/Connection.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Domain;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Cycle\Annotated\Annotation\Column;
+use Cycle\Annotated\Annotation\Entity;
+
+#[Entity(
+    repository: ConnectionRepositoryInterface::class
+)]
+class Connection
+{
+    public function __construct(
+        #[Column(type: 'string(36)', primary: true, typecast: 'uuid')]
+        public Uuid $uuid,
+        #[Column(type: 'string')]
+        public string $name,
+        #[Column(type: 'string')]
+        public string $host,
+        #[Column(type: 'string')]
+        public string $user = 'root',
+        #[Column(type: 'integer')]
+        public int $port = 22,
+        #[Column(type: 'string', nullable: true, default: null)]
+        public ?string $password = null,
+        #[Column(type: 'string', nullable: true, default: null)]
+        public ?string $privateKey = null,
+    ) {
+    }
+}
diff --git a/app/modules/SshTunnel/Domain/ConnectionFactoryInterface.php b/app/modules/SshTunnel/Domain/ConnectionFactoryInterface.php
new file mode 100644
index 00000000..1b3e013b
--- /dev/null
+++ b/app/modules/SshTunnel/Domain/ConnectionFactoryInterface.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Domain;
+
+interface ConnectionFactoryInterface
+{
+    public function make(
+        string $name,
+        string $host,
+        string $user = 'root',
+        int $port = 22,
+        ?string $password = null,
+        ?string $privateKey = null,
+    ): Connection;
+}
diff --git a/app/modules/SshTunnel/Domain/ConnectionRepositoryInterface.php b/app/modules/SshTunnel/Domain/ConnectionRepositoryInterface.php
new file mode 100644
index 00000000..1b61d05e
--- /dev/null
+++ b/app/modules/SshTunnel/Domain/ConnectionRepositoryInterface.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Domain;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Cycle\ORM\RepositoryInterface;
+
+/**
+ * @extends RepositoryInterface<Connection>
+ */
+interface ConnectionRepositoryInterface extends RepositoryInterface
+{
+    /**
+     * Create connection entity.
+     */
+    public function store(Connection $connection): bool;
+
+    /**
+     * Delete connection entity by primary key.
+     */
+    public function deleteByPK(Uuid $uuid): bool;
+}
diff --git a/app/modules/SshTunnel/Domain/Events/ConnectionStored.php b/app/modules/SshTunnel/Domain/Events/ConnectionStored.php
new file mode 100644
index 00000000..feba8172
--- /dev/null
+++ b/app/modules/SshTunnel/Domain/Events/ConnectionStored.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Domain\Events;
+
+use App\Application\Broadcasting\Channel\SettingsChannel;
+use App\Application\Broadcasting\ShouldBroadcastInterface;
+use Modules\SshTunnel\Domain\Connection;
+use Stringable;
+
+final class ConnectionStored implements ShouldBroadcastInterface
+{
+    public function __construct(
+        public readonly Connection $connection,
+    ) {
+    }
+
+    public function getEventName(): string
+    {
+        return 'ssh.connection.stored';
+    }
+
+    public function getBroadcastTopics(): iterable|string|Stringable
+    {
+        return new SettingsChannel();
+    }
+
+    public function jsonSerialize(): array
+    {
+        return [
+            'name' => $this->connection->name,
+            'host' => $this->connection->host,
+            'user' => $this->connection->user,
+            'port' => $this->connection->port,
+            'privateKey' => $this->connection->privateKey,
+        ];
+    }
+}
diff --git a/app/modules/SshTunnel/Exception/ConnectionException.php b/app/modules/SshTunnel/Exception/ConnectionException.php
new file mode 100644
index 00000000..fc0d43c6
--- /dev/null
+++ b/app/modules/SshTunnel/Exception/ConnectionException.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Exception;
+
+class ConnectionException extends \DomainException
+{
+
+}
diff --git a/app/modules/SshTunnel/Exception/ConnectionNotEstablishedException.php b/app/modules/SshTunnel/Exception/ConnectionNotEstablishedException.php
new file mode 100644
index 00000000..a957baea
--- /dev/null
+++ b/app/modules/SshTunnel/Exception/ConnectionNotEstablishedException.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Exception;
+
+final class ConnectionNotEstablishedException extends ConnectionException
+{
+
+}
diff --git a/app/modules/SshTunnel/Exception/ConnectionNotFoundException.php b/app/modules/SshTunnel/Exception/ConnectionNotFoundException.php
new file mode 100644
index 00000000..68a1bd1c
--- /dev/null
+++ b/app/modules/SshTunnel/Exception/ConnectionNotFoundException.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Exception;
+
+final class ConnectionNotFoundException extends ConnectionException
+{
+
+}
diff --git a/app/modules/SshTunnel/Interfaces/Commands/CloseHandler.php b/app/modules/SshTunnel/Interfaces/Commands/CloseHandler.php
new file mode 100644
index 00000000..02223557
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Commands/CloseHandler.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Commands;
+
+use App\Application\Commands\ConnectSshTunnel;
+use Modules\SshTunnel\Application\SshTunnelService;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+use Modules\SshTunnel\Exception\ConnectionException;
+use Modules\SshTunnel\Exception\ConnectionNotFoundException;
+use Spiral\Cqrs\Attribute\CommandHandler;
+
+final class CloseHandler
+{
+    public function __construct(
+        private readonly ConnectionRepositoryInterface $connections,
+        private readonly SshTunnelService $service,
+    ) {
+    }
+
+    #[CommandHandler]
+    public function __invoke(ConnectSshTunnel $command): void
+    {
+        $connection = $this->connections->findByPK($command->connectionUuid);
+
+        if ($connection === null) {
+            throw new ConnectionNotFoundException('Connection not found');
+        }
+
+        try {
+            $this->service->disconnect($connection);
+        } catch (\Throwable $e) {
+            throw new ConnectionException(previous: $e);
+        }
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Commands/ConnectHandler.php b/app/modules/SshTunnel/Interfaces/Commands/ConnectHandler.php
new file mode 100644
index 00000000..fe10909b
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Commands/ConnectHandler.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Commands;
+
+use App\Application\Commands\ConnectSshTunnel;
+use Modules\SshTunnel\Application\SshTunnelService;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+use Modules\SshTunnel\Exception\ConnectionNotEstablishedException;
+use Modules\SshTunnel\Exception\ConnectionNotFoundException;
+use Spiral\Cqrs\Attribute\CommandHandler;
+
+final class ConnectHandler
+{
+    public function __construct(
+        private readonly ConnectionRepositoryInterface $connections,
+        private readonly SshTunnelService $service,
+    ) {
+    }
+
+    #[CommandHandler]
+    public function __invoke(ConnectSshTunnel $command): void
+    {
+        $connection = $this->connections->findByPK($command->connectionUuid);
+
+        if ($connection === null) {
+            throw new ConnectionNotFoundException('Connection not found');
+        }
+
+        try {
+            $this->service->connect($connection);
+        } catch (\Throwable $e) {
+            throw new ConnectionNotEstablishedException(previous: $e);
+        }
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Commands/DeleteConnectionHandler.php b/app/modules/SshTunnel/Interfaces/Commands/DeleteConnectionHandler.php
new file mode 100644
index 00000000..7d2bc9f9
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Commands/DeleteConnectionHandler.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Commands;
+
+use App\Application\Commands\DeleteSshConnection;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+use Spiral\Cqrs\Attribute\CommandHandler;
+
+final class DeleteConnectionHandler
+{
+    public function __construct(
+        private readonly ConnectionRepositoryInterface $connections,
+    ) {
+    }
+
+    #[CommandHandler]
+    public function __invoke(DeleteSshConnection $command): void
+    {
+        $this->connections->deleteByPK($command->connectionUuid);
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Commands/StoreConnectionHandler.php b/app/modules/SshTunnel/Interfaces/Commands/StoreConnectionHandler.php
new file mode 100644
index 00000000..16cf5069
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Commands/StoreConnectionHandler.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Commands;
+
+use App\Application\Commands\StoreSshConnection;
+use Modules\SshTunnel\Domain\ConnectionFactoryInterface;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+use Modules\SshTunnel\Domain\Events\ConnectionStored;
+use Psr\EventDispatcher\EventDispatcherInterface;
+use Spiral\Cqrs\Attribute\CommandHandler;
+
+final class StoreConnectionHandler
+{
+    public function __construct(
+        private readonly EventDispatcherInterface $dispatcher,
+        private readonly ConnectionRepositoryInterface $connections,
+        private readonly ConnectionFactoryInterface $factory,
+    ) {
+    }
+
+    #[CommandHandler]
+    public function __invoke(StoreSshConnection $command): void
+    {
+        $connection = $this->factory->make(
+            name: $command->name,
+            host: $command->host,
+            user: $command->user,
+            port: $command->port,
+            password: $command->password,
+            privateKey: $command->privateKey,
+        );
+
+        $this->connections->store($connection);
+
+        $this->dispatcher->dispatch(
+            new ConnectionStored(connection: $connection),
+        );
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Console/SshTunnelCommand.php b/app/modules/SshTunnel/Interfaces/Console/SshTunnelCommand.php
new file mode 100644
index 00000000..b65cf5f4
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Console/SshTunnelCommand.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Console;
+
+use Modules\SshTunnel\Application\CommandBuilder;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+use Modules\SshTunnel\Exception\ConnectionException;
+use Spiral\Console\Attribute\Argument;
+use Spiral\Console\Attribute\AsCommand;
+use Spiral\Console\Command;
+use Symfony\Component\Console\Command\SignalableCommandInterface;
+use Symfony\Component\Process\Process;
+
+#[AsCommand(
+    name: 'ssh:tunnel',
+    description: 'Create SSH tunnel to remote server',
+)]
+final class SshTunnelCommand extends Command implements SignalableCommandInterface
+{
+    #[Argument(description: 'SSH connection UUID')]
+    public string $connectionUuid;
+
+    private Process $process;
+    private ?string $provateKeyPath = null;
+
+    public function __invoke(ConnectionRepositoryInterface $connections, CommandBuilder $builder): int
+    {
+        $connection = $connections->findByPK($this->connectionUuid);
+
+        if (!$connection) {
+            $this->error('Connection not found');
+            return self::FAILURE;
+        }
+
+        $command = $builder->host($connection->host)
+            ->sshPort($connection->port)
+            ->user($connection->user)
+            ->privateKey($connection->privateKey)
+            ->forwardPort(8000, 8000)
+            ->forwardPort(1025, 1025)
+            ->forwardPort(9913, 9913)
+            ->forwardPort(9912, 9912)
+            ->build();
+
+        if ($this->isVerbose()) {
+            $this->info('SSH command:');
+            $this->comment(\implode(' ', $command));
+        }
+
+        $this->provateKeyPath = $builder->getPrivateKey();
+
+        $this->process = new Process(command: $command, timeout: null);
+        $this->process->start(function () {
+            $this->writeln('SSH tunnel started');
+        });
+
+        $this->process->wait(function ($type, $buffer) {
+            $this->writeln($buffer);
+        });
+
+        return self::SUCCESS;
+    }
+
+    public function getSubscribedSignals(): array
+    {
+        return [
+            SIGINT,
+            SIGTERM,
+        ];
+    }
+
+    public function handleSignal(int $signal,): int|false
+    {
+        $this->process->stop();
+
+        $this->warning('SSH tunnel stopped');
+
+        if ($this->provateKeyPath) {
+            unlink($this->provateKeyPath);
+            $this->warning('SSH private key deleted');
+        }
+
+        return false;
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Http/Controllers/DeleteAction.php b/app/modules/SshTunnel/Interfaces/Http/Controllers/DeleteAction.php
new file mode 100644
index 00000000..5b96c617
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Http/Controllers/DeleteAction.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Http\Controllers;
+
+use App\Application\Commands\DeleteSshConnection;
+use App\Application\Domain\ValueObjects\Uuid;
+use App\Application\HTTP\Response\ResourceInterface;
+use App\Application\HTTP\Response\SuccessResource;
+use Spiral\Cqrs\CommandBusInterface;
+use Spiral\Router\Annotation\Route;
+
+final class DeleteAction
+{
+    #[Route(route: 'ssh/<uuid>', name: 'ssh.delete', methods: 'DELETE', group: 'api')]
+    public function __invoke(CommandBusInterface $bus, Uuid $uuid): ResourceInterface
+    {
+        $bus->dispatch(
+            new DeleteSshConnection(
+                connectionUuid: $uuid,
+            ),
+        );
+
+        return new SuccessResource();
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Http/Controllers/ShowAction.php b/app/modules/SshTunnel/Interfaces/Http/Controllers/ShowAction.php
new file mode 100644
index 00000000..3d6e86c6
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Http/Controllers/ShowAction.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Http\Controllers;
+
+use App\Application\Commands\FindSshConnectionByUuid;
+use App\Application\Domain\ValueObjects\Uuid;
+use App\Application\Exception\EntityNotFoundException;
+use App\Application\HTTP\Response\ResourceInterface;
+use Modules\SshTunnel\Interfaces\Http\Resources\SshConnectionResource;
+use Spiral\Cqrs\QueryBusInterface;
+use Spiral\Http\Exception\ClientException\NotFoundException;
+use Spiral\Router\Annotation\Route;
+
+final class ShowAction
+{
+    #[Route(route: 'ssh/<uuid>', name: 'ssh.show', methods: 'GET', group: 'api')]
+    public function __invoke(QueryBusInterface $bus, Uuid $uuid): ResourceInterface
+    {
+        try {
+            return new SshConnectionResource(
+                $bus->ask(
+                    new FindSshConnectionByUuid(
+                        uuid: $uuid,
+                    ),
+                ),
+            );
+        } catch (EntityNotFoundException $e) {
+            throw new NotFoundException($e->getMessage());
+        }
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Http/Controllers/StoreAction.php b/app/modules/SshTunnel/Interfaces/Http/Controllers/StoreAction.php
new file mode 100644
index 00000000..118bb72e
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Http/Controllers/StoreAction.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Http\Controllers;
+
+use App\Application\Commands\StoreSshConnection;
+use App\Application\HTTP\Response\ResourceInterface;
+use App\Application\HTTP\Response\SuccessResource;
+use Modules\SshTunnel\Interfaces\Http\Request\StoreRequest;
+use Spiral\Cqrs\CommandBusInterface;
+use Spiral\Router\Annotation\Route;
+
+final class StoreAction
+{
+    #[Route(route: 'ssh/connection', name: 'ssh.store', methods: 'POST', group: 'api')]
+    public function __invoke(StoreRequest $request, CommandBusInterface $bus): ResourceInterface
+    {
+        $bus->dispatch(
+            new StoreSshConnection(
+                name: $request->name,
+                host: $request->host,
+                user: $request->user,
+                port: $request->port,
+                privateKey: $request->privateKey,
+            ),
+        );
+
+        return new SuccessResource();
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Http/Request/StoreRequest.php b/app/modules/SshTunnel/Interfaces/Http/Request/StoreRequest.php
new file mode 100644
index 00000000..23750871
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Http/Request/StoreRequest.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Http\Request;
+
+use Spiral\Filters\Attribute\CastingErrorMessage;
+use Spiral\Filters\Attribute\Input\Post;
+use Spiral\Filters\Attribute\Setter;
+use Spiral\Filters\Model\Filter;
+use Spiral\Filters\Model\FilterDefinitionInterface;
+use Spiral\Filters\Model\HasFilterDefinition;
+use Spiral\Validator\FilterDefinition;
+
+final class StoreRequest extends Filter implements HasFilterDefinition
+{
+    #[Post]
+    #[CastingErrorMessage('Name must be a string')]
+    public string $name;
+
+    #[Post]
+    #[CastingErrorMessage('Host must be a string')]
+    public string $host;
+
+    #[Post]
+    #[CastingErrorMessage('User must be a string')]
+    public string $user = 'root';
+
+    #[Post]
+    #[Setter(filter: 'intval')]
+    public int $port = 22;
+
+    #[Post(key: 'private_key')]
+    #[CastingErrorMessage('Password must be a string')]
+    public string $privateKey;
+
+    public function filterDefinition(): FilterDefinitionInterface
+    {
+        return new FilterDefinition([
+            'name' => ['required', 'string'],
+            'host' => ['required', 'string'],
+            'user' => ['required', 'string'],
+            'port' => ['int'],
+            'privateKey' => ['required', 'string'],
+        ]);
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Http/Resources/SshConnectionResource.php b/app/modules/SshTunnel/Interfaces/Http/Resources/SshConnectionResource.php
new file mode 100644
index 00000000..e552fa5e
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Http/Resources/SshConnectionResource.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Http\Resources;
+
+use App\Application\HTTP\Response\JsonResource;
+use Modules\SshTunnel\Domain\Connection;
+
+/**
+ * @property-read Connection $data
+ */
+final class SshConnectionResource extends JsonResource
+{
+    public function __construct(Connection $data)
+    {
+        parent::__construct($data);
+    }
+
+    protected function mapData(): array|\JsonSerializable
+    {
+        return [
+            'uuid' => (string)$this->data->uuid,
+            'name' => $this->data->name,
+            'host' => $this->data->host,
+            'port' => $this->data->port,
+            'user' => $this->data->user,
+            'private_key' => $this->data->privateKey,
+        ];
+    }
+}
diff --git a/app/modules/SshTunnel/Interfaces/Queries/FindSshConnectionByUuidHandler.php b/app/modules/SshTunnel/Interfaces/Queries/FindSshConnectionByUuidHandler.php
new file mode 100644
index 00000000..f61011eb
--- /dev/null
+++ b/app/modules/SshTunnel/Interfaces/Queries/FindSshConnectionByUuidHandler.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Interfaces\Queries;
+
+use App\Application\Commands\FindSshConnectionByUuid;
+use App\Application\Exception\EntityNotFoundException;
+use Modules\SshTunnel\Domain\Connection;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+use Spiral\Cqrs\Attribute\QueryHandler;
+
+final class FindSshConnectionByUuidHandler
+{
+    public function __construct(
+        private readonly ConnectionRepositoryInterface $connections,
+    ) {
+    }
+
+    #[QueryHandler]
+    public function __invoke(FindSshConnectionByUuid $query): Connection
+    {
+        $connection = $this->connections->findByPK((string)$query->uuid);
+        if (!$connection) {
+            throw new EntityNotFoundException(
+                \sprintf('Connection with given uuid [%s] was not found.', (string)$query->uuid),
+            );
+        }
+
+        return $connection;
+    }
+}
diff --git a/app/modules/SshTunnel/Mapper/JsonConnectionMapper.php b/app/modules/SshTunnel/Mapper/JsonConnectionMapper.php
new file mode 100644
index 00000000..25ae4ebe
--- /dev/null
+++ b/app/modules/SshTunnel/Mapper/JsonConnectionMapper.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Modules\SshTunnel\Mapper;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Modules\SshTunnel\Domain\Connection;
+
+final class JsonConnectionMapper
+{
+    public function fromArray(array $data): Connection
+    {
+        return new Connection(
+            uuid: Uuid::fromString($data['uuid']),
+            name: $data['name'],
+            host: $data['host'],
+            user: $data['user'],
+            port: $data['port'],
+            password: $data['password'],
+            privateKey: $data['privateKey'],
+        );
+    }
+
+    public function toArray(Connection $connection): array
+    {
+        return [
+            'uuid' => (string)$connection->uuid,
+            'name' => $connection->name,
+            'host' => $connection->host,
+            'user' => $connection->user,
+            'port' => $connection->port,
+            'password' => $connection->password,
+            'privateKey' => $connection->privateKey,
+        ];
+    }
+}
diff --git a/app/src/Application/Bootloader/PersistenceBootloader.php b/app/src/Application/Bootloader/PersistenceBootloader.php
index 560c2251..cd019d68 100644
--- a/app/src/Application/Bootloader/PersistenceBootloader.php
+++ b/app/src/Application/Bootloader/PersistenceBootloader.php
@@ -4,6 +4,7 @@
 
 namespace App\Application\Bootloader;
 
+use App\Application\Persistence\ArraySshConnectionRepository;
 use App\Application\Persistence\CacheEventRepository;
 use App\Application\Persistence\CycleOrmEventRepository;
 use App\Application\Persistence\MongoDBEventRepository;
@@ -12,7 +13,10 @@
 use Cycle\ORM\Select;
 use Modules\Events\Domain\Event;
 use Modules\Events\Domain\EventRepositoryInterface;
+use Modules\SshTunnel\Domain\Connection;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
 use MongoDB\Database;
+use Ramsey\Uuid\Uuid;
 use Spiral\Boot\Bootloader\Bootloader;
 use Spiral\Boot\EnvironmentInterface;
 use Spiral\Cache\CacheStorageProviderInterface;
@@ -20,22 +24,28 @@
 
 final class PersistenceBootloader extends Bootloader
 {
-    protected const SINGLETONS = [
-        EventRepositoryInterface::class => [self::class, 'createRepository'],
-        CycleOrmEventRepository::class => [self::class, 'createCycleOrmEventRepository'],
-        MongoDBEventRepository::class => [self::class, 'createMongoDBEventRepository'],
-        CacheEventRepository::class => [self::class, 'createCacheEventRepository'],
-    ];
+    public function defineSingletons(): array
+    {
+        return [
+            // Events
+            EventRepositoryInterface::class => [self::class, 'creatEventRepository'],
+            CycleOrmEventRepository::class => [self::class, 'createCycleOrmEventRepository'],
+            MongoDBEventRepository::class => [self::class, 'createMongoDBEventRepository'],
+            CacheEventRepository::class => [self::class, 'createCacheEventRepository'],
 
-    private function createCacheEventRepository(
-        CacheStorageProviderInterface $provider,
-    ): EventRepositoryInterface {
-        return new CacheEventRepository($provider);
+            // SSH Tunnel
+            ConnectionRepositoryInterface::class => [self::class, 'creatConnectionRepository'],
+        ];
+    }
+
+    private function creatConnectionRepository(): ConnectionRepositoryInterface
+    {
+        return new ArraySshConnectionRepository([]);
     }
 
-    private function createRepository(
+    private function creatEventRepository(
         FactoryInterface $factory,
-        EnvironmentInterface $env
+        EnvironmentInterface $env,
     ): EventRepositoryInterface {
         return match ($env->get('PERSISTENCE_DRIVER', 'cache')) {
             'cycle' => $factory->make(CycleOrmEventRepository::class),
@@ -45,9 +55,15 @@ private function createRepository(
         };
     }
 
+    private function createCacheEventRepository(
+        CacheStorageProviderInterface $provider,
+    ): EventRepositoryInterface {
+        return new CacheEventRepository($provider);
+    }
+
     private function createCycleOrmEventRepository(
         ORMInterface $orm,
-        EntityManagerInterface $manager
+        EntityManagerInterface $manager,
     ): CycleOrmEventRepository {
         return new CycleOrmEventRepository($manager, new Select($orm, Event::class));
     }
@@ -55,7 +71,7 @@ private function createCycleOrmEventRepository(
     private function createMongoDBEventRepository(Database $database): MongoDBEventRepository
     {
         return new MongoDBEventRepository(
-            $database->selectCollection('events')
+            $database->selectCollection('events'),
         );
     }
 }
diff --git a/app/src/Application/Broadcasting/Channel/SettingsChannel.php b/app/src/Application/Broadcasting/Channel/SettingsChannel.php
new file mode 100644
index 00000000..d602dac9
--- /dev/null
+++ b/app/src/Application/Broadcasting/Channel/SettingsChannel.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Broadcasting\Channel;
+
+final class SettingsChannel extends Channel
+{
+    public function __construct()
+    {
+        parent::__construct('settings');
+    }
+}
diff --git a/app/src/Application/Commands/CloseSshTunnel.php b/app/src/Application/Commands/CloseSshTunnel.php
new file mode 100644
index 00000000..217e5053
--- /dev/null
+++ b/app/src/Application/Commands/CloseSshTunnel.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Commands;
+
+use App\Application\Domain\ValueObjects\Uuid;
+
+final class CloseSshTunnel
+{
+    public function __construct(
+        public readonly Uuid $connectionUuid,
+    ) {}
+}
diff --git a/app/src/Application/Commands/ConnectSshTunnel.php b/app/src/Application/Commands/ConnectSshTunnel.php
new file mode 100644
index 00000000..13eda3cb
--- /dev/null
+++ b/app/src/Application/Commands/ConnectSshTunnel.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Commands;
+
+use App\Application\Domain\ValueObjects\Uuid;
+
+final class ConnectSshTunnel
+{
+    public function __construct(
+        public readonly Uuid $connectionUuid,
+    ) {}
+}
diff --git a/app/src/Application/Commands/DeleteSshConnection.php b/app/src/Application/Commands/DeleteSshConnection.php
new file mode 100644
index 00000000..2d5a8ebb
--- /dev/null
+++ b/app/src/Application/Commands/DeleteSshConnection.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Commands;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Spiral\Cqrs\CommandInterface;
+
+final class DeleteSshConnection implements CommandInterface
+{
+    public function __construct(
+        public Uuid $connectionUuid,
+    ) {}
+}
diff --git a/app/src/Application/Commands/FindSshConnectionByUuid.php b/app/src/Application/Commands/FindSshConnectionByUuid.php
new file mode 100644
index 00000000..0f280016
--- /dev/null
+++ b/app/src/Application/Commands/FindSshConnectionByUuid.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Commands;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Spiral\Cqrs\QueryInterface;
+
+class FindSshConnectionByUuid implements QueryInterface
+{
+    public function __construct(
+        public readonly Uuid $uuid
+    ) {}
+}
diff --git a/app/src/Application/Commands/StoreSshConnection.php b/app/src/Application/Commands/StoreSshConnection.php
new file mode 100644
index 00000000..06aa1638
--- /dev/null
+++ b/app/src/Application/Commands/StoreSshConnection.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Commands;
+
+use Spiral\Cqrs\CommandInterface;
+
+final class StoreSshConnection implements CommandInterface
+{
+    public function __construct(
+        public string $name,
+        public string $host,
+        public string $user = 'root',
+        public int $port = 22,
+        public ?string $password = null,
+        public ?string $privateKey = null,
+    ) {}
+}
diff --git a/app/src/Application/Persistence/ArraySshConnectionRepository.php b/app/src/Application/Persistence/ArraySshConnectionRepository.php
new file mode 100644
index 00000000..92ff42a2
--- /dev/null
+++ b/app/src/Application/Persistence/ArraySshConnectionRepository.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Application\Persistence;
+
+use App\Application\Domain\ValueObjects\Uuid;
+use Modules\SshTunnel\Domain\Connection;
+use Modules\SshTunnel\Domain\ConnectionRepositoryInterface;
+
+final class ArraySshConnectionRepository implements ConnectionRepositoryInterface
+{
+    public function __construct(
+        private array $connections = [],
+    ) {}
+
+    public function store(Connection $connection): bool
+    {
+        $this->connections[(string)$connection->uuid] = $connection;
+        return true;
+    }
+
+    public function deleteByPK(Uuid $uuid): bool
+    {
+        if (!isset($this->connections[(string)$uuid])) {
+            return false;
+        }
+
+        unset($this->connections[(string)$uuid]);
+        return true;
+    }
+
+    /**
+     * @param Uuid|string $id
+     */
+    public function findByPK(mixed $id): ?object
+    {
+        if (!isset($this->connections[(string)$id])) {
+            return null;
+        }
+
+        return $this->connections[(string)$id];
+    }
+
+    public function findOne(array $scope = []): ?object
+    {
+        throw new \BadMethodCallException('Not available');
+    }
+
+    public function findAll(array $scope = []): iterable
+    {
+        return $this->connections;
+    }
+}
diff --git a/app/src/Interfaces/Centrifugo/ConnectService.php b/app/src/Interfaces/Centrifugo/ConnectService.php
index 1483375e..611fe9af 100644
--- a/app/src/Interfaces/Centrifugo/ConnectService.php
+++ b/app/src/Interfaces/Centrifugo/ConnectService.php
@@ -4,6 +4,8 @@
 
 namespace App\Interfaces\Centrifugo;
 
+use App\Application\Broadcasting\Channel\EventsChannel;
+use App\Application\Broadcasting\Channel\SettingsChannel;
 use RoadRunner\Centrifugo\Payload\ConnectResponse;
 use RoadRunner\Centrifugo\Request;
 use RoadRunner\Centrifugo\Request\RequestInterface;
@@ -19,9 +21,12 @@ public function handle(RequestInterface $request): void
         try {
             $request->respond(
                 new ConnectResponse(
-                    user: (string) $request->getAttribute('user_id'),
-                    channels: ['events'],
-                )
+                    user: (string)$request->getAttribute('user_id'),
+                    channels: [
+                        (string)new EventsChannel(),
+                        (string)new SettingsChannel(),
+                    ],
+                ),
             );
         } catch (\Throwable $e) {
             $request->error($e->getCode(), $e->getMessage());
diff --git a/composer.json b/composer.json
index 6d98bb4b..125a93c6 100644
--- a/composer.json
+++ b/composer.json
@@ -41,8 +41,10 @@
         "spiral/framework": "^3.10",
         "spiral/nyholm-bridge": "^1.3",
         "spiral/roadrunner-bridge": "^3.0",
+        "spiral/roadrunner-services": "^2.1",
         "spiral/validator": "^1.1",
         "symfony/mime": "^6.2",
+        "symfony/process": "^6.3",
         "symfony/var-dumper": "^6.1",
         "zbateson/mail-mime-parser": "^2.0"
     },