svnscha - ssh

How to: Use Docker Remote Contexts with SSH

2025-10-10T00:00:00+00:00

The Problem: When Your Laptop Becomes a Jet Engine

Working on resource-intensive Docker projects often turns laptops into jet engines. The fans spin up, the CPU overheats, and performance degrades significantly. This is especially problematic when working with limited resources - lightweight laptops, VDI sessions, or simply wanting to preserve your hardware.

An SSH-based Docker context keeps the development tools on your local machine while running Docker workloads on a more capable remote host. Your laptop stays responsive and the remote system handles the heavier work.

Step 1: Prerequisites

Before we start, ensure you have:

SSH access configured to your remote Docker host with a proper SSH config entry like:

# ~/.ssh/config
Host docker-remote
  HostName 10.10.10.10
  IdentityFile ~/.ssh/id_rsa
  User ubuntu

Your user is in the docker group on the remote host:

sudo usermod -aG docker $USER

That's all the setup needed! Now let's create the Docker context.

Step 2: Create the SSH-Based Docker Context

Creating the Docker context is incredibly simple when you have SSH properly configured.

Create Your SSH-Based Remote Context

Create a new context using your SSH config host:

docker context create docker-remote --docker host=ssh://docker-remote

That's it! Docker will use your existing SSH configuration, including the hostname, user, and identity file you've already set up.

The beauty of this approach: No daemon.json changes, no TCP configuration, no port forwarding, no firewall rules, no TLS certificate generation - just leverage your existing SSH security infrastructure. Simple and elegant!

Check Your Current Contexts

First, let's see what contexts you currently have:

docker context ls

You'll probably see something like:

NAME              DESCRIPTION                               DOCKER ENDPOINT
default *         Current DOCKER_HOST based configuration   npipe:////./pipe/docker_engine
desktop-linux     Docker Desktop                            npipe:////./pipe/dockerDesktopLinuxEngine
desktop-windows   Docker Desktop                            npipe:////./pipe/dockerDesktopWindowsEngine
docker-remote                                               ssh://docker-remote

Test the Connection

Let's verify everything works:

docker --context docker-remote container ls

If you see your remote containers listed (or an empty list if none are running), congratulations! You're successfully connected to your remote Docker host via SSH.

Step 3: Make It Your Default (Optional)

If you want to use the remote context by default, you can switch to it:

docker context use docker-remote

Now all your docker commands will automatically use the remote host:

docker container ls
# This now runs on your remote host!

Environment Variable Override

For more granular control, you can also use the DOCKER_CONTEXT environment variable:

# Windows PowerShell
$env:DOCKER_CONTEXT = "docker-remote"

# Linux/macOS
export DOCKER_CONTEXT=docker-remote

This approach is particularly useful in CI/CD scenarios or when you want different shells to use different contexts.

Why SSH is Better

Using SSH for Docker remote contexts offers several advantages over TCP:

Security: All communication is encrypted by default
Authentication: Leverages existing SSH keys and authentication methods
No daemon configuration: No need to modify Docker daemon settings on the remote host
Firewall friendly: Uses standard SSH port (22)
Audit trail: SSH logging provides better security monitoring

Switching Between Contexts

Need to switch back to local Docker for something? Easy:

# List available contexts
docker context ls

# Switch to local Docker
docker context use default

# Or use a specific context for one command
docker --context default container ls

Bonus: PowerShell Function for Quick Context Switching

Here's a handy PowerShell function to make switching contexts even easier. Add this to your PowerShell profile for instant remote Docker activation:

Edit Your PowerShell Profile

First, open your PowerShell profile for editing:

notepad $PROFILE

If the file doesn't exist yet, PowerShell will ask if you want to create it - say yes.

Add the Function

Add this function to your profile:

function docker-remote-activate {
    $env:DOCKER_CONTEXT = "docker-remote"
    Write-Host "Docker context switched to remote host"
}

Replace "docker-remote" with whatever you named your remote context.

Save and Reload

Save the file and reload your PowerShell profile:

. $PROFILE

Usage

Now you can instantly activate remote Docker in any PowerShell session:

# Activate remote Docker for this session only
docker-remote-activate

# Now all Docker commands run remotely
docker ps
docker images
docker build .

The beauty of this approach is that it only affects the current PowerShell session - open a new terminal window and you're back to local Docker by default!

Global vs Terminal-Specific Context Switching

You have two ways to switch between local and remote Docker contexts:

Global Context Switching

Affects all terminals system-wide:

# Switch globally to remote
docker context use docker-remote

# Switch back to local
docker context use default

Terminal-Specific Context

Affects only the current terminal session:

# Terminal 1: Remote context
docker-remote-activate
docker ps  # runs remotely

# Terminal 2: Still local context  
docker ps  # runs locally

Whether you prefer global context switching or terminal-specific control, Docker remote contexts give you the flexibility to work exactly how you want.

Summary

Using SSH-based Docker remote contexts provides a secure, simple solution for offloading resource-intensive Docker operations to remote hosts. With just a single command and proper SSH configuration, you can transform your development workflow without compromising security.

The SSH approach eliminates the complexity of daemon configuration while providing enterprise-grade security through encrypted communication and existing authentication infrastructure.

Key Benefits:

Secure by default (encrypted communication)
No daemon configuration required
Uses standard SSH authentication
Works with existing SSH infrastructure
Simple one-command setup

References:

Windows: Install integrated OpenSSH Server

2025-04-03T00:00:00+00:00

Tired of everyone SSHing into Linux? Flip the script: SSH into Windows from your Linux box. Works great with VSCode Remote too. Here's how to enable the built-in OpenSSH server on Windows.

Step 1: Check Installed OpenSSH Components

First, open a PowerShell window with administrator privileges. Let's see what's already installed:

Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH*'

You might see output indicating that the client is installed but not the server:

Name  : OpenSSH.Client~~~~0.0.1.0
State : Installed

Name  : OpenSSH.Server~~~~0.0.1.0
State : NotPresent

Step 2: Install the OpenSSH Server

If the server isn't present, let's bring it on board. Run:

Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0

Step 3: Start and Enable the SSH Server

Now, let's get the sshd service up and running:

Start-Service sshd

And ensure it starts automatically with Windows:

Set-Service -Name sshd -StartupType 'Automatic'

That's it.

Simplify SSH

2024-10-03T00:00:00+00:00

Why, You Ask?

I was tired of entering my SSH key passphrase every time I connected to a server. The setup below lets ssh-agent remember it for the current terminal session and also keeps host settings in one place.

It's time-consuming and frustrating. I'm tired of it.

Getting Started

So, you've got your shiny new SSH key and every time you want to connect to a server, you're greeted with that ever-familiar password prompt. Sure, typing your SSH key passphrase every time is good for security, but, come on - who wants to do that? I mean, I don't know about you, but I've got enough passwords to remember without constantly dealing with this nonsense.

Let's save ourselves some time and effort by getting the SSH agent to remember our keys for us. That way, you can just run your commands like the seasoned developer you are without worrying about the whole "password entering" thing every single time.

Step 1: Start the SSH Agent

First things first - let's get the SSH agent up and running. It's like your personal SSH butler, here to remember your key so you don't have to.

Open up your terminal and type:

eval $(ssh-agent -s)

Boom! Now the agent is running in the background, ready to hold your keys like the responsible little daemon it is.

Step 2: Add your key to the SSH Agent

Now that the agent is up, let's give it your key. You only need to do this once per session, and the agent will keep it ready for you.

ssh-add ~/.ssh/your_key

Replace your_key with the name of your private key file. Enter the passphrase once and ssh-agent will remember it for the rest of the terminal session.

Step 3: Configure your SSH setup to be even lazier (I mean efficient)

Okay, we've got the agent running and the key added, but we can take it one step further. Why not tell SSH exactly what key to use for which server, so you never have to worry about it picking the wrong one?

To do this, we're going to set up a ~/.ssh/config file. If you don't have this file yet, don't worry - it's as easy as creating it:

touch ~/.ssh/config

Now, crack open that file with your favorite text editor and set things up like this:

Host your-server-alias
    HostName your.server.com
    User your-username
    IdentityFile ~/.ssh/your_key
    IdentitiesOnly yes

Breaking it down

Host: You can use any alias here that makes sense to you. This is what you'll type when you want to connect to this server.
HostName: The actual domain or IP address of the server.
User: Your username on that server, so you do not have to specify it each time.
IdentityFile: The path to your SSH private key.
IdentitiesOnly yes: Tells SSH to use only this key, rather than trying every key it can find in the agent (which is how you avoid that annoying "user mismatch" issue).

Step 4: Create a wrapper script for SSH Agent control

Alright, you want control over when your SSH agent starts up - totally understandable! Instead of running the agent automatically on login (which might feel a bit too autonomous), we'll create a neat little wrapper script. You can trigger it whenever you feel like starting the agent and adding your SSH key for the session.

Here's how to set that up.

Create the wrapper script

Let's create a script that starts the SSH agent, adds your key, and gives you control over when it runs. We'll call this script init-ssh, and we'll stick it somewhere like /usr/local/bin so it's available from anywhere in your terminal.

Create the script: Open your terminal and create the init-ssh script:
```
sudo nano /usr/local/bin/init-ssh
```

Add the script content: Paste the following content into the file:

#!/bin/bash

# Start the SSH agent
eval $(ssh-agent -s)

# Add the key to the agent
ssh-add ~/.ssh/your_key

# Optional: Display agent status for peace of mind
ssh-add -l

Make the script executable: Give the script executable permissions:
```
sudo chmod +x /usr/local/bin/init-ssh
```

How to use the script

Whenever you want to start your SSH agent for a session, just run:

. init-ssh

This will start the agent, add your key, and show you a list of the keys currently loaded in the agent. You've got full control - start the agent when you want, stop it when you're done, and enjoy a password-free SSH experience for the duration of that session.

Optional: Stopping the SSH Agent

If you want to stop the SSH agent after you're done with it, you can either let it die when you close your terminal or manually kill it with:

eval $(ssh-agent -k)

That way, you get all the convenience of an SSH agent when you need it, without it running indefinitely in the background. You're now in complete control of your SSH setup, and you can keep things secure and efficient, exactly the way you like it.

Happy SSH'ing!