DEV Community: Garis Space

Adminer With Custom Login Servers Selector Plugin Run In Docker

Garis Space — Sun, 21 Jan 2024 12:56:51 +0000

In the world of database management, Adminer has emerged as a compact yet powerful tool for handling a wide range of database tasks. While its core functionality is impressive, the real power of Adminer lies in its extensibility through plugins. In this post, we’ll dive into the creation and implementation of a custom plugin for Adminer.

Repo: https://github.com/garis-space/adminer-login-servers

The Genesis of the Plugin
The Adminer Login Server Selector Plugin was born out of a need to streamline the process of connecting to various database servers. Traditionally, connecting to different servers in Adminer requires manual entry of connection details — a process that can be tedious and error-prone. This plugin elegantly solves this problem by allowing users to select their desired server from a predefined list.

How Does the Plugin Work?
The plugin, written in PHP, integrates seamlessly with Adminer. Here’s a breakdown of its functionality:

Dynamic Server List: The plugin reads a JSON-formatted list of server configurations from an environment variable, ADMINER_SERVERS. This list can include details for multiple servers, each with its own driver, server address, username, password, and database name.
User Interface Integration: In the Adminer login form, the plugin injects a dropdown menu populated with the server names defined in the ADMINER_SERVERS variable. Users can select a server from this dropdown, and the plugin automatically fills in the corresponding connection details.
Customization and Flexibility: The plugin is flexible and easily customizable. Users can add, remove, or modify server configurations in the environment variable without altering the plugin’s code.

Adminer Login Servers Plugin Code

<?php

/**
 * Display servers list from defined ADMINER_SERVERS variable.
 * @link https://www.adminer.org/plugins/#use
 * @author https://github.com/garis-space
*/
class AdminerLoginServers {
  /**
   * Set servers from environment variable
   * Example:
   * $_ENV['ADMINER_SERVERS'] = '{
   *  "Server 1":{"driver":"pgsql","server":"","username":"","password":"","db":""},
   *  "Server 2":{"driver":"pgsql","server":"","username":"","password":"","db":""}
   * }';
  */
  function __construct() {
    $this->servers = array();
    if ($_ENV['ADMINER_SERVERS']) {
      $this->servers = json_decode($_ENV['ADMINER_SERVERS'], true);
    }

    if ($_POST["auth"]["custom_server"]) {
      $key = $_POST["auth"]["custom_server"];
      $_POST["auth"]["driver"] = $this->servers[$key]["driver"];
      $_POST["auth"]["server"] = $this->servers[$key]["server"];
      $_POST["auth"]["username"] = $this->servers[$key]["username"];
      $_POST["auth"]["password"] = $this->servers[$key]["password"];
      $_POST["auth"]["db"] = $this->servers[$key]["db"];
    }
  }

  function loginFormField($name, $heading, $value) {
    if ($name == 'driver') {
      return '<tr><th>Driver<td>' . $value;
    } elseif ($name == 'server') {
      return '<tr><th>Host<td>' . $value;
    } elseif ($name == 'db' && $_ENV['ADMINER_SERVERS'] != '') {
      $out = $heading . $value;
      $out .= '<tr><th><td>or';
      $out .= '<tr><th>Server<td><select name="auth[custom_server]">';
      $out .= '<option value="" selected>--</option>';
      foreach ($this->servers as $serverName => $serverConfig) {
          $out .= '<option value="' . htmlspecialchars($serverName) . '">' . htmlspecialchars($serverName) . '</option>';
      }
      $out .= '</select>';
      return $out;
    }
  }
}

return new AdminerLoginServers();

Configuring Servers via compose.yml or .env
One of the standout features of this plugin is its ability to integrate with Docker Compose and environment variable configurations. This integration offers a high degree of flexibility and ease of use, especially in development and testing environments.

In the compose.yml file, you can define in the ADMINER_SERVERS variable only the server data you want to keep in your repository and save the rest in the .env file. As you have surely noticed, the ADMINER_SERVERS variable from the .env file is added to the end of the permanently defined ADMINER_SERVERS list from compose.yml file. This allows you to separate different login credentials for different environments.

compose.yml file

x-env-file: &env-file
  env_file: .env
x-restart: &restart
  restart: always

services:
  postgres-12:
    ...

  postgres-16:
    ...

  adminer:
    <<: [*env-file, *restart]
    image: adminer:latest
    container_name: adminer
    environment:
      # Login Servers Plugin
      - ADMINER_SERVERS={
          "[env1] PostgreSQL 12":{
            "driver":"pgsql",
            "server":"${POSTGRES_12_HOST}",
            "username":"${POSTGRES_12_USER:-postgres}",
            "password":"${POSTGRES_12_PASSWORD}",
            "db":"${POSTGRES_12_DB:-postgres}"
          },
          "[env2] PostgreSQL 16":{
            "driver":"pgsql",
            "server":"${POSTGRES_16_HOST}",
            "username":"${POSTGRES_16_USER:-postgres}",
            "password":"${POSTGRES_16_PASSWORD}",
            "db":"${POSTGRES_16_DB:-postgres}"
          } ${ADMINER_SERVERS}
        }
    volumes:
      - ./adminer/login-servers.php:/var/www/html/plugins-enabled/login-servers.php
    ports:
      - 8080:8080

.env file

# Adminer
ADMINER_SERVERS=',
  "[env3] GCP Cloud SQL":{
    "driver":"pgsql",
    "server":"postgres-16",
    "username":"postgres",
    "password":"super_secret_password",
    "db":"postgres"
  },
  "[env4] AWS RDS":{
    "driver":"pgsql",
    "server":"postgres-16",
    "username":"postgres",
    "password":"super_secret_password",
    "db":"postgres"
  },
  "[env5] Azure SQL":{
    "driver":"pgsql",
    "server":"postgres-16",
    "username":"postgres",
    "password":"super_secret_password",
    "db":"postgres"
  }
'

Conclusion
The Adminer Login Server Selector Plugin is a testament to the power of customization in software development. By bridging the gap between user convenience and functional flexibility, this plugin not only enhances the Adminer experience but also demonstrates the vast possibilities within the realms of PHP and Docker. It’s an excellent example of how a small, focused tool can make a significant impact on workflow efficiency.

Django (polls app) development in Kubernetes using Tilt with PostgreSQL, Adminer and MinIO installed using Helm

Garis Space — Fri, 02 Dec 2022 16:36:01 +0000

Sample Django project demonstrating how to use Tilt with Helm to develop a Django application in Kubernetes. This project uses the polls app from the Django documentation and is configured to use PostgreSQL and MinIO as the database and file storage backend respectively.

Step 1 - Start the local Kubernetes cluster from Docker Desktop

Go to Docker Desktop > Preferences > Kubernetes > Enable Kubernetes and click Apply & Restart

`Optional` Step 2 - Set the kubectl context to Docker Desktop

If you have multiple kubectl contexts, you can set the current context to Docker Desktop using the following command:

kubectl config get-contexts
kubectl config use-context docker-desktop

Step 3 - Install Tilt for macOs (if not already installed)

Follow the instructions on the Tilt website to install Tilt.

brew install tilt-dev/tap/tilt

Step 4 - Local development using Tilt

# Clone the repository
git clone https://github.com/garis-space/django-polls-app-tilt-k8s-pg-minio.git
cd django-polls-app-tilt-k8s-pg-minio

# Environment variables (edit as needed)
cp .env.example .env

The Tiltfile

# Disable Titl analytics
analytics_settings(enable=False)

# Disable Tilt redacted secret
secret_settings(disable_scrub=True)

# Load Tilt extensions (https://github.com/tilt-dev/tilt-extensions)
load('ext://helm_resource', 'helm_resource', 'helm_repo')
load('ext://uibutton', 'cmd_button', 'bool_input', 'text_input', 'location')
load('ext://secret', 'secret_create_generic', 'secret_from_dict')
load('ext://configmap', 'configmap_create')
load('ext://dotenv', 'dotenv')

# Check if Kubernetes context is set to docker-desktop
if k8s_context() != 'docker-desktop':
    fail('Kubernetes context is not set to docker-desktop')

# Read .env file
dotenv('.env')

###
# PostgreSQL
###

# Create secrets for PostgreSQL
k8s_yaml(secret_from_dict("django-polls-postgresql", inputs = {
    'postgres-password' : os.getenv('POSTGRESQL_PASSWORD')
}))

# Add PostgreSQL Helm resource (https://artifacthub.io/packages/helm/bitnami/postgresql)
helm_repo('bitnami', 'https://charts.bitnami.com/bitnami')
helm_resource(
    name='postgresql',
    chart='bitnami/postgresql',
    namespace='default',
    flags=[
        '--set=image.tag=15-debian-11',
        # Load secret values from created secret
        '--set=global.postgresql.auth.existingSecret=django-polls-postgresql',
    ],
    labels=['database']
)

###
# Adminer
###

# Add Adminer Helm resource (https://artifacthub.io/packages/helm/cetic/adminer)
helm_repo('cetic', 'https://cetic.github.io/helm-charts')
helm_resource(
    name='adminer',
    chart='cetic/adminer',
    namespace='default',
    flags=[
        '--set=service.type=LoadBalancer',
        '--set=service.port=8080',
        '--set=config.externalserver=postgresql',
    ],
    labels=['database']
)

###
# MinIO
###

# Create secrets for MinIO
k8s_yaml(secret_from_dict("django-polls-minio", inputs = {
    'rootUser' : os.getenv('MINIO_ROOT_USER'),
    'rootPassword' : os.getenv('MINIO_ROOT_PASSWORD'),
}))

# Add MinIO Helm resource (https://artifacthub.io/packages/helm/minio/minio)
helm_repo('minio', 'https://charts.min.io')
#update_settings(k8s_upsert_timeout_secs=120)
helm_resource(
    name='minio-s3',
    chart='minio/minio',
    namespace='default',
    flags=[
        # Load secret values from created secret
        '--set=existingSecret=django-polls-minio',
        '--set=service.type=LoadBalancer',
        '--set=mode=standalone',
        '--set=persistence.enabled=false',
        '--set=replicas=1',
        '--set=consoleService.type=LoadBalancer',
        '--set=resources.requests.memory=256Mi',
        # Add buckets
        '--set=buckets[0].name=static,buckets[0].policy=public',
        '--set=buckets[1].name=media,buckets[1].policy=public',
    ],
    labels=['storage']
)

###
# Django
###

# Create a secrets from .env file for Django app
secret_create_generic('django-polls', from_env_file='.env')

# Build Django polls app
docker_build(
    'app/django-polls',
    context='./django-polls',
    live_update=[
        sync('django-polls', '/app'),
        run('cd /app && pip install -r requirements-dev.txt',
            trigger=['./django-polls/requirements.txt', './django-polls/requirements-dev.txt']),
        run('cd /app && python manage.py migrate',
            trigger=['./django-polls/polls/migrations']),
        run('cd /app && python manage.py collectstatic --noinput',
            trigger=['./django-polls/polls/static']),
    ],
)

# Kubernetes deployment
k8s_yaml('./django-polls/k8s.yml')

# Kubernetes create resource
k8s_resource(
    'django-polls',
    port_forwards=8000,
    resource_deps=['postgresql', 'minio'],
    labels=['app'],
)

###
# Custom commands for Tilt
###

# Add a button to quickly run a command in a pod
pod_exec_script = '''
    set -eu
    # get k8s pod name from tilt resource name
    POD_NAME="$(tilt get kubernetesdiscovery "$resource" -ojsonpath='{.status.pods[0].name}')"
    kubectl exec "$POD_NAME" -- $command
'''
cmd_button('podexec',
    argv=['sh', '-c', pod_exec_script],
    location=location.NAV,
    icon_name='',
    text='Exec in a pod',
    inputs=[
        text_input('resource'),
        text_input('command'),
    ]
)

# Add a button to quickly create a superuser
cmd_button('django-polls:createsuperuser',
    argv=['sh', '-c', pod_exec_script],
    env=[
        'resource=django-polls',
        'command=python manage.py createsuperuser --noinput --username {} --email {}'.format(
            os.getenv('DJANGO_SUPERUSER_USERNAME'),
            os.getenv('DJANGO_SUPERUSER_EMAIL')
        ),
    ],
    resource='django-polls',
    icon_name='login',
    text='create superuser',
)

# Add a button to run tests
cmd_button('django-polls:test',
    argv=['sh', '-c', pod_exec_script],
    env=[
        'resource=django-polls',
        'command=python manage.py test',
    ],
    resource='django-polls',
    icon_name='check_circle',
    text='run app tests',
)

When you run tilt up for the first time, Tilt will read .env file, set the environment variables and create secrets in the cluster for the Django app, PostgreSQL and minIO, then install Helm charts for PostgreSQL (with simple adminer database management), MinIO (with init buckets) and deploy the Django application (migrations and collectstatic will be run automatically) using previously created secrets to the local Kubernetes cluster. This will take a few minutes. Subsequent runs of tilt up will be much faster.

# Start Tilt
tilt up

Step 5 - Create a new superuser

From Tilt UI (http://localhost:10350), click from the left sidebar "django-polls" resource and then click the "create super user" button. This will create a new super user for the Django admin site with password from the DJANGO_SUPERUSER_PASSWORD environment variable.

Step 6 - Access the Django admin site

You can access the Django admin site at https://localhost:8000/admin. Login using the username and password from the DJANGO_SUPERUSER_USERNAME and DJANGO_SUPERUSER_PASSWORD environment variables.

Step 7 - Access the MinIO Console

You can access the MinIO Console at https://localhost:9001. Login using the username and password from the MINIO_ROOT_USER and MINIO_ROOT_PASSWORD environment variables.

Step 8 - Access the Adminer PostgreSQL database management

You can access the Adminer PostgreSQL database management at https://localhost:8080. Login using the username and password from the POSTGRESQL_USER and POSTGRESQL_PASSWORD environment variables.

Step 9 - Stop Tilt

Tilt will remove the Helm charts, secrets and the Django application from the local Kubernetes cluster.

tilt down

Deploy Kubernetes Dashboard with Metrics Server using Terraform and Helm on Docker Desktop

Garis Space — Mon, 28 Nov 2022 15:21:22 +0000

This is a simple example of how to deploy the Kubernetes Dashboard and Metrics Server using Terraform and Helm on Docker Desktop.

Step 1 - Start the local Kubernetes cluster from Docker Desktop

Go to Docker Desktop > Preferences > Kubernetes > Enable Kubernetes and click Apply & Restart

`Optional` Step 2 - Set the kubectl context to Docker Desktop

If you have multiple kubectl contexts, you can set the current context to Docker Desktop using the following command:



kubectl config use-context docker-desktop

Step 3 - Install Terraform for macOs (if not already installed)

Download and install Terraform from https://www.terraform.io/downloads.html



brew tap hashicorp/tap && brew install hashicorp/tap/terraform

Step 4 - Clone repository



git clone https://github.com/garis-space/tf-helm-kubernetes-dashboard-and-metrics-server.git
cd tf-helm-kubernetes-dashboard-and-metrics-server

In the root directory of this repository, you will find a main.tf file which contains the Terraform configuration to deploy the Kubernetes Dashboard and Metrics Server.



terraform {
  required_providers {
    # Kubernetes provider
    kubernetes = {
      source  = "hashicorp/kubernetes"
    }
    # Helm provider
    helm = {
      source  = "hashicorp/helm"
    }
  }
}

# Path to config file for the Kubernetes provider as variable
variable "kubeconfig" {
  type = string
  # Load the kubeconfig from your home directory (default location for Docker Desktop Kubernetes)
  default = "~/.kube/config"
}

# Kubernetes provider configuration
provider "kubernetes" {
  config_path = var.kubeconfig
}

# Helm provider configuration
provider "helm" {
  # Local Kubernetes cluster from Docker Desktop
  kubernetes {
    # Load the kubeconfig from your home directory
    config_path = var.kubeconfig
  }
}

###
# Create a new Kubernetes namespace for the application deployment
###
resource "kubernetes_namespace" "kubernetes_dashboard" {
  metadata {
    name = "kubernetes-dashboard"
  }
}

###
# Install the Kubernetes Dashboard using the Helm provider
###
resource "helm_release" "kubernetes_dashboard" {
  # Name of the release in the cluster
  name       = "kubernetes-dashboard"

  # Name of the chart to install
  repository = "https://kubernetes.github.io/dashboard/"

  # Version of the chart to use
  chart      = "kubernetes-dashboard"

  # Wait for the Kubernetes namespace to be created
  depends_on = [kubernetes_namespace.kubernetes_dashboard]

  # Set the namespace to install the release into
  namespace  = kubernetes_namespace.kubernetes_dashboard.metadata[0].name

  # Set service type to LoadBalancer
  set {
    name  = "service.type"
    value = "LoadBalancer"
  }

  # Set service external port to 9080
  set {
    name  = "service.externalPort"
    value = "9080"
  }

  # Set protocol to HTTP (not HTTPS)
  set {
    name  = "protocolHttp"
    value = "true"
  }

  # Enable insecure login (no authentication)
  set {
    name  = "enableInsecureLogin"
    value = "true"
  }

  # Enable cluster read only role (no write access) for the dashboard user
  set {
    name  = "rbac.clusterReadOnlyRole"
    value = "true"
  }

  # Enable metrics scraper (required for the CPU and memory usage graphs)
  set {
    name  = "metricsScraper.enabled"
    value = "true"
  }

  # Wait for the release to be deployed
  wait = true
}

###
# Install the Metrics Server using the Helm provider
###
resource "helm_release" "metrics_server" {
  # Name of the release in the cluster
  name       = "metrics-server"

  # Name of the chart to install
  repository = "https://kubernetes-sigs.github.io/metrics-server/"

  # Version of the chart to use
  chart      = "metrics-server"

  # Wait for the Kubernetes Dashboard and Kubernetes namespace to be created
  depends_on = [helm_release.kubernetes_dashboard, kubernetes_namespace.kubernetes_dashboard]

  # Set the namespace to install the release into
  namespace  = kubernetes_namespace.kubernetes_dashboard.metadata[0].name

  # Recent updates to the Metrics Server do not work with self-signed certificates by default.
  # Since Docker For Desktop uses such certificates, you’ll need to allow insecure TLS
  set {
    name  = "args"
    value = "{--kubelet-insecure-tls=true}"
  }

  # Wait for the release to be deployed
  wait = true
}

# Output metadata of the Kubernetes Dashboard release
output "kubernetes_dashboard_service_metadata" {
  value = helm_release.kubernetes_dashboard.metadata
}

# Output metadata of the Metrics Server release
output "metrics_server_service_metadata" {
  value = helm_release.metrics_server.metadata
}

# Output the URL of the Kubernetes Dashboard
output "kubernetes_dashboard_url" {
  value = "http://localhost:9080"
}

Step 5 - Initialize Terraform



terraform init

Step 6 - Deploy the Kubernetes Dashboard and Metrics Server



terraform apply

Step 7 - Access the Kubernetes Dashboard



# Open the Kubernetes Dashboard (please wait a few minutes for the Kubernetes Dashboard to start and the Metrics Server to collect data)
open https://localhost:9080

`Optional` Step 8 - Clean up



terraform destroy

JS & CSS snippet to detect and style if dark mode

Garis Space — Mon, 19 Sep 2022 13:46:27 +0000

This JavaScript snippet detects if the user is in dark mode. And if so, it returns true.

const isDarkMode = () =>
  globalThis.matchMedia?.("(prefers-color-scheme:dark)").matches ?? false;

// Usage
isDarkMode();

The prefers-color-scheme CSS media feature lets you detect if the user's system is set to dark mode or light mode.

@media (prefers-color-scheme: dark) {
  body {
    background-color: black;
    color: white;
  }
}

@media (prefers-color-scheme: light) {
  body {
    background-color: white;
    color: black;
  }
}

DEV Community: Garis Space

Adminer With Custom Login Servers Selector Plugin Run In Docker

Django (polls app) development in Kubernetes using Tilt with PostgreSQL, Adminer and MinIO installed using Helm

Step 1 - Start the local Kubernetes cluster from Docker Desktop

Optional Step 2 - Set the kubectl context to Docker Desktop

Step 3 - Install Tilt for macOs (if not already installed)

Step 4 - Local development using Tilt

Step 5 - Create a new superuser

Step 6 - Access the Django admin site

Step 7 - Access the MinIO Console

Step 8 - Access the Adminer PostgreSQL database management

Step 9 - Stop Tilt

Deploy Kubernetes Dashboard with Metrics Server using Terraform and Helm on Docker Desktop

Step 1 - Start the local Kubernetes cluster from Docker Desktop

Optional Step 2 - Set the kubectl context to Docker Desktop

Step 3 - Install Terraform for macOs (if not already installed)

Step 4 - Clone repository

Step 5 - Initialize Terraform

Step 6 - Deploy the Kubernetes Dashboard and Metrics Server

Step 7 - Access the Kubernetes Dashboard

Optional Step 8 - Clean up

JS & CSS snippet to detect and style if dark mode

`Optional` Step 2 - Set the kubectl context to Docker Desktop

`Optional` Step 2 - Set the kubectl context to Docker Desktop

`Optional` Step 8 - Clean up