Docker and Kubernetes in Edgely Console

Reach a Docker engine on your computer, over SSH or over TCP, work with its containers, images, networks and Compose projects, and browse a Kubernetes cluster through your kubeconfig.

Applies to
Edgely Console
Updated

Edgely Console manages Docker engines and Kubernetes clusters from the same app as your servers: containers, images, networks, volumes and Compose projects on one side, pods, deployments, services, ingresses and storage claims on the other, without typing docker or kubectl. This page covers how to connect to each, and what the explorers show and do.

Checked on 2026-10-26 against the code of Edgely Console 0.9.4; the image updates on 2026-11-12 against the code of Edgely Console 1.4.0, on Downloads.

Docker: three ways to reach an engine

Every Docker engine starts from the Docker Environments page: open Connections > Docker Environments in the ribbon, or the Docker Environments section of the sidebar. An _environment_ is a saved Docker connection; it is kept on this computer only, and exports and sync do not carry it. The sidebar's filter by type narrows the list to Local, SSH or TCP environments, and Details shows an environment's settings, when it was last used and how often.

Local Docker

Local Docker is always the first entry, marked Default. Double-click it, or click Open Local Docker.

On macOS and Linux, Edgely looks for the engine's socket at ~/.docker/run/docker.sock, /var/run/docker.sock and Docker Desktop's docker.raw.sock, in that order. On Windows it reads DOCKER_HOST first, then Docker Desktop's named pipes (docker_engine, then dockerDesktopLinuxEngine).

Docker over SSH

The recommended way to manage a Docker host you already reach by SSH.

  1. On the Docker Environments page, click Add Environment.
  2. Leave Connection Type on SSH, give the environment a name, and pick a saved connection in SSH Connection.
  3. Click Add, then open the new environment.

Edgely runs the docker command on the remote host through the SSH connection, so the host needs the Docker CLI and the SSH user needs the right to use Docker. Nothing else is exposed on the host, and the SSH connection's jump host is followed (see Jump hosts and bastions).

Docker over TCP

For an engine that listens on a TCP port.

  1. Click Add Environment and set Connection Type to TCP.
  2. Enter a name, the host and the port (2375 by default).
  3. Click Add, then open the new environment.

Edgely talks to that port over plain, unencrypted TCP. An engine reachable that way gives anyone who can reach the port full control of the host: keep it to a network you trust, and use SSH for anything else.

What each kind of environment does

Most of the explorer works the same on all three. These operations run on an environment reached over SSH: pause, unpause, kill, rename, container stats, resource limits, image tag, history, build and push, disk usage, system prune and volume prune. Pull Image runs on Local and TCP environments; on an SSH environment, pull from the host's terminal (docker pull) and click Refresh. Inspect shows the full docker inspect JSON over SSH, and a summary on Local and TCP.

The Docker explorer

The toolbar runs across the top: search, Refresh and Disconnect, plus Create Container on the Containers tab and Pull Image and Build Image on the Images tab. Below it, three columns:

  • Left: the environment card (its name, its type, the number of containers and images) and quick stats: running, stopped and paused containers.
  • Middle: the tabs Containers, Images, Networks, Volumes, Compose and System, and the list of the selected tab. The search box filters containers by name, image or ID, and images by tag or ID.
  • Right: the selected container or image in detail, or statistics when nothing is selected. It can be collapsed for more room.

A connection that fails shows Connection Failed with the reason and a Retry button. An operation that fails once connected shows its error in a red banner under the toolbar, which you can dismiss. Click Refresh after changing something outside Edgely.

Containers

Each row of the container list shows the container's name, a status dot, its image and state (nginx:latest • Running), up to two of its ports, and a power button to start, stop or unpause it. The dot is green when the container runs, grey when it is stopped or created, yellow when paused, blue when restarting and red when dead. Show All off keeps only the running containers.

Select a container to see its details on the right, with the power buttons at the top and Actions below them.

ActionWhat it doesWhen
StartStarts a stopped containerStopped
StopStops it gracefullyRunning
RestartStops and starts itRunning
KillStops it at once, after confirmationRunning, SSH environment
Pause / UnpauseFreezes every process inside it, and resumes themSSH environment
RemoveDeletes the container, after confirmationNot running and not paused
LogsOpens its log in a new tabAny
InspectShows its configuration in a dialog, with Copy JSONAny
StatsCPU, memory, network I/O, block I/O and the number of processes, with a refresh buttonRunning, SSH environment
RenameChanges its nameSSH environment
CloneCreates a stopped copy under a new name: same image, command, environment, network, restart policy, volumes and published ports. Volumes and host folders are shared with the source, not copied. While the source is running, paused or restarting its published ports are left out, since a host port cannot be bound twice. The entrypoint, labels, health check and resource limits are not copied; the dialog says which of these apply before you press CloneAny
FilesBrowses the container's file systemRunning
Resource LimitsChanges its CPU shares, memory, swap and process limitsSSH environment
ExecOpens a shell inside it (see below)Running

The detail panel lists the container's Image, Created, Hostname, Network and Restart policy, then its port mappings, TCP and UDP. For everything else (command, environment variables, mounts, labels), use Inspect.

Image updates

Check for updates, beside the filters, asks the registry of each running container's image whether its tag (nginx:1.25, ghcr.io/org/app:latest) now names a newer image than the one the container runs. Edgely asks with a HEAD request, which does not count against Docker Hub's pull limit, and keeps each registry's answer for a day: a second check the same day asks nobody.

  • A container with a newer image shows Update available, and the Updates filter keeps only those.
  • An image pinned to a digest (nginx@sha256:...), or built or loaded on the host, shows nothing: it is never outdated.
  • A private registry that asks for a sign-in shows Sign-in needed. Click Choose a credential in the detail panel and pick the vault credential for that registry: a password credential, or an API client with its token. Edgely keeps the choice on this computer, per registry, and checks again.
  • A registry that cannot be reached shows Not checked, with the reason in the detail panel.

Update, in the detail panel of a container with a newer image, pulls the tag again and replaces the container with a new one of the same name on the new image. Its dialog says what will happen before anything does.

  • The new container keeps the published ports, the volumes and their data (an image's anonymous volumes included, such as a database's data folder), the network, the restart policy, and the command and environment the container was given. What the old image itself set is left to the new image.
  • Labels, the user, devices, capabilities and resource limits are not carried over.
  • A running container stops while it is replaced, then the new one starts. A stopped container is replaced by a stopped one.
  • The old container is renamed <name>-edgely-replaced and removed only once the new one is in place. If a step fails, whatever was created is removed, and the old container gets its name back and runs again if it was running.
  • A container that belongs to a Compose project is not replaced: the dialog says to update it with its compose file (docker compose pull, then docker compose up -d).

On an SSH environment, the pull uses the remote host's own registry sign-in (docker login there). On Local Docker and on a TCP environment, it signs in with the credential chosen for the registry, since the Docker API has no docker login. A registry that refuses the pull leaves the container as it was.

Logs

Logs opens a tab with the last 500 lines, timestamps on. Its toolbar:

ControlWhat it does
FollowReads the newest lines again every two seconds while it is on; the button then reads Pause and the Live badge shows. Off when the tab opens
TimestampsShows or hides the time at the start of each line
Auto-scrollKeeps the view on the newest line, or leaves it where you scrolled
WrapWraps long lines, or scrolls sideways
The lines menuHow many lines to load: 100, 200, 500, 1000 or 5000 lines
Zoom out / Zoom inText size from 8 to 24 pixels
RefreshLoads the last lines again
Copy logsCopies the lines, without the colour codes

Colour codes in the output are drawn as colours, ERROR, WARN, INFO and DEBUG are highlighted, and every line is numbered.

Docker Exec

Select a running container and click Exec: a terminal tab opens with a shell inside the container, bash when the image has it and /bin/sh otherwise. It is the same terminal as the SSH terminal, with your theme and text size from Settings > Appearance, without the SSH terminal's toolbar: no search and no zoom. Copy and paste with Cmd + C and Cmd + V on macOS, Ctrl + Shift + C and Ctrl + Shift + V on Windows and Linux.

EnvironmentHow the shell runs
LocalThrough the Docker Engine's exec API on the local socket or pipe
SSHdocker exec on the remote host, through a new SSH connection for each tab
TCPThrough the Docker Engine's exec API over TCP

An image with no shell at all cannot host a session: it ends at once ("The container shell session has ended."). Type exit or press Ctrl + D to leave; closing the tab also asks the shell to exit before it disconnects, and the container keeps running. Reconnect opens a fresh shell.

Changes made inside a container (installed packages, edited files) are lost when it is removed, unless the path is on a volume or a bind mount, where they land on the host.

Images, networks, volumes and Compose

  • Images: Pull Image and Build Image in the toolbar; on an image, Run, Tag Image, History / Layers, Push Image and Remove.
  • Networks: create one (driver, subnet, gateway, internal), remove it, and connect or disconnect a container.
  • Volumes: create, remove and prune.
  • Compose: every project the listed containers belong to. Start All, Stop All and Restart All start, stop or restart the containers that carry the project's label. Turn Show All on in the Containers tab to see a project whose containers are all stopped.
  • System: disk usage and prune.

Kubernetes: adding a cluster

Clusters are added on the Third Party Platforms page: open Connections > Third Party Platforms in the ribbon, or the Third Party Platforms section of the sidebar.

Importing a kubeconfig

  1. Click Import Kubeconfig in the toolbar.
  2. The Import from Kubeconfig dialog reads your default kubeconfig and lists its contexts, the active one marked Current. Use the folder button to read another file, and Refresh contexts to read it again.
  3. Tick the contexts you want (or Select All) and click Import Selected.

Each ticked context becomes a platform of its own, named after the context. When it connects, Edgely reads that context from the file it came from, the default kubeconfig or the one you picked, which Edgely remembers by its path. Importing saves the platforms in the vault, so with the vault locked Edgely asks you to unlock it first.

Edgely signs in to the cluster with the credentials of the kubeconfig context. The kubeconfig stays where it is on disk: Edgely keeps its path, never its content.

Adding a cluster by hand

Click New Platform, pick Kubernetes as the Platform Type, enter a Name and a URL starting with http:// or https://, and click Create. The cluster connects with the current context of your default kubeconfig. To choose another, add a line Context: <name> to the platform's Notes, and Kubeconfig: <path> to read another file; this is what an import writes.

The Kubernetes explorer

  • Top bar: the cluster, the Namespace selector (one namespace, or All Namespaces), the connection state (Connected, Connecting..., Disconnected, with Connect to connect again, or an error), AI Assist, and refresh.
  • Left: the resource kinds in sections (Nodes, Workloads, Network, Storage, Config), and the cluster's nodes with their readiness and memory.
  • Middle: the pods, deployments, services, ingresses or PVCs of the selected kind, in the selected namespace, coloured by status.
  • Right: the selected resource in detail. The list starts with a Cluster Overview card: select it for the cluster's health, its version, and its number of nodes, namespaces, pods and deployments.

The explorer reads the cluster when you connect, when you refresh, and after each of your own actions: click refresh after changing something outside Edgely. AI Assist asks the AI Assistant for help with the cluster, giving it the cluster, the namespace and the kind of resource you are looking at; the answer suggests the kubectl commands to use.

Pods

A pod's details list its namespace, status, the node it runs on, its pod and host IPs, its owner, the total of its restarts, and each container with its image and readiness, and its restart count when there was one.

  • Logs: the Pod Logs dialog, with a container picker for a pod with several containers, the number of lines, Follow (reads again every two seconds) and refresh.
  • Exec: a shell in the Pod Exec dialog, in the pod's first container, bash when it has it. The pod must be running.
  • Port Forward: forwards a port on your computer, on 127.0.0.1, to a port of a running pod. The dialog lists the pod's active forwards, and they stop when you disconnect.
  • YAML: the pod's YAML, read only.
  • Delete: deletes the pod after confirmation. It shows as Terminating, and the list follows until it is gone.

Deployments

A deployment's details list its desired, ready and available replicas and its rollout strategy.

  • Scale: sets the number of replicas, with a warning when you choose 0.
  • Restart: restarts its pods with a fresh rollout.
  • YAML: the deployment's YAML, read only.

Services, ingresses and storage claims

  • Services: the type (ClusterIP, NodePort or LoadBalancer), the cluster IP and the first external IP, the port mappings, and the selector that picks the service's pods.
  • Ingresses: the class, the TLS hosts, and each rule from host and path to service and port.
  • PVCs: the storage class, the capacity, the access mode and the bound volume.

Something missing or wrong?

Documentation gaps are bugs. Tell us which page you were reading and what you expected to find.

Send feedback →

Product names, logos and brands mentioned on this page are the property of their respective owners. They are used for identification and comparison only, and their use does not imply any affiliation with or endorsement by them.