How to Access phpMyAdmin using an SSH tunnel

Your database is the beating heart of your application. Leaving phpMyAdmin exposed to the open internet is like leaving the door to the engine room wide open on a Firefly-class transport... anyone drifting by can walk right in. An SSH tunnel is the quiet gate that keeps the wrong folks out while letting you work in peace.

What This Is About

Secure access. That's it. You need to manage a phpMyAdmin instance on a remote Bitnami server, and you need to do it without painting a target on your database for every scanner and bot crawling the web. The tool? PuTTY. The method? An SSH tunnel that maps a local port on your Windows machine to the remote server's internal services.

No magic. Just careful configuration and a few minutes of focused setup.

Before You Touch Anything

Gather your prerequisites first. Rushing past this step is how things break.

You need four things:

1. Your server's IP address. Know where you're going. 2. Your Bitnami application's default password. This is the key to phpMyAdmin itself. 3. A server configured with a public key. The handshake has to be set up on the other end. 4. Access to the corresponding private key (.ppk file). This lives on your local machine.

Missing any one of these? Stop. Get them sorted. Time × Focus = Attention... and scattered attention during security configuration is how mistakes happen.

The Four Stops in PuTTY

PuTTY configuration isn't complicated, but it does require you to visit four distinct sections in the right order. Think of it like a pre-flight checklist. Skip a step and you're not getting off the ground.

Stop 1: Session

Open PuTTY. In the Host Name field, enter your server's IP address. Put the same address in the Saved Sessions field. This is your destination... the ship you're docking with.

Don't save yet. We've got more to configure.

Stop 2: Connection → SSH → Auth

Navigate the category tree on the left to Connection → SSH → Auth. Here you point PuTTY to your private key file. Browse to the `.ppk` file on your local machine.

This is your credential. Public key authentication means no password prompt for the SSH connection itself... your key does the talking. It's cleaner and significantly more secure than password-based SSH.

Stop 3: Connection → SSH → Tunnels

This is the core of the whole operation. The port forwarding configuration.

- Source Port: `8888` - Destination: `localhost:80` - Click Add.

What you've just done: told PuTTY that when you visit port 8888 on your own machine, it should route that traffic through the encrypted SSH connection to port 80 on the remote server. The remote server's phpMyAdmin instance listens on port 80 internally... but it's not exposed to the internet. Your tunnel is the only path in.

`localhost:80` in the destination field refers to the remote server's localhost, not yours. That distinction matters. The tunnel makes the remote service behave as if it's local.

Stop 4: Connection → Data

Navigate to Connection → Data. Enter `bitnami` in the Auto-login username field. This saves you from typing the SSH username every time you connect.

Small convenience. Adds up over dozens of connections.

Save and Launch

Now go back to the Session section. Click Save. This stores your entire configuration so you never have to walk through these four stops again for this server.

Click Open.

PuTTY establishes the SSH session and the tunnel activates in the background. A terminal window opens... that's your live encrypted connection.

Walking Through the Gate

Open your browser. Type:

``` http://127.0.0.1:8888/phpmyadmin ```

`127.0.0.1` is your own machine. Port `8888` is the local end of the tunnel you just built. The request travels through the SSH tunnel, hits port 80 on the remote server, and phpMyAdmin's login screen appears in your browser.

Log in with: - Username: `root` - Password: Your Bitnami application password

That's it. You're in. Securely.

Why This Matters

Exposing phpMyAdmin to the public internet is one of the most common security mistakes in web server management. Automated bots scan for it constantly. An SSH tunnel eliminates that attack surface entirely. The service never touches the public web... it only exists through your encrypted connection.

Light doesn't fight darkness... it just shows up. And in server security, the SSH tunnel just shows up between you and your data, quietly doing its job without fanfare.

Quick Reference

| PuTTY Section | What to Enter | |---|---| | Session → Host Name | Server IP address | | SSH → Auth | Path to your `.ppk` private key | | SSH → Tunnels | Source: `8888` / Destination: `localhost:80` | | Data | Auto-login username: `bitnami` |

| Browser Access | | |---|---| | URL | `http://127.0.0.1:8888/phpmyadmin` | | Username | `root` | | Password | Bitnami application password |

Save the PuTTY session once. Use it every time. Quietly working in the background... exactly how good security should be.

Security doesn't have to be loud or complicated. Four configuration stops. One saved session. A browser pointed at localhost. Your database stays hidden from the internet while you manage it like it's sitting right next to you. The tunnel does the heavy lifting so you can focus on the work that actually matters. If you're managing a Bitnami stack on Windows and haven't set this up yet... today's a good day to close that open door. 💙

--- Source: https://www.youtube.com/watch?v=9VdcQLDmYII