Hit "fake" protocols. Fake infrastructure. No stakes.

# PostgreSQL playground (psql)
# Database: exampledb
# User:     playground
# Password: playgroundpass

psql -h exampledomain.org -p 5432 -U playground -d exampledb

-- Inside psql, start a fresh session sandbox:
SELECT init_session();

-- Now interact with the session-local copy of customers:
SELECT * FROM customers LIMIT 10;

# PostgreSQL playground - Python example
# pip install psycopg2-binary
import psycopg2

conn = psycopg2.connect(
    host="exampledomain.org",
    port=5432,
    user="playground",
    password="playgroundpass",
    dbname="exampledb",
)
try:
    cur = conn.cursor()

    # Initialize per-connection session (temp tables, etc.)
    cur.execute("SELECT init_session();")
    cur.fetchall()  # consume result

    # Work with the session-local customers table
    cur.execute("SELECT * FROM customers LIMIT 10;")
    rows = cur.fetchall()
    for row in rows:
        print(row)

    cur.close()
finally:
    conn.close()

// PostgreSQL playground - Go example
// go get github.com/lib/pq
package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/lib/pq"
)

func main() {
    dsn := "host=exampledomain.org " +
        "port=5432 " +
        "user=playground " +
        "password=playgroundpass " +
        "dbname=exampledb " +
        "sslmode=disable"

    db, err := sql.Open("postgres", dsn)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Initialize per-connection session
    if _, err := db.Exec("SELECT init_session();"); err != nil {
        log.Fatal("init_session failed:", err)
    }

    rows, err := db.Query("SELECT * FROM customers LIMIT 10;")
    if err != nil {
        log.Fatal("query failed:", err)
    }
    defer rows.Close()

    cols, err := rows.Columns()
    if err != nil {
        log.Fatal(err)
    }

    for rows.Next() {
        values := make([]interface{}, len(cols))
        ptrs := make([]interface{}, len(cols))
        for i := range values {
            ptrs[i] = &values[i]
        }

        if err := rows.Scan(ptrs...); err != nil {
            log.Fatal(err)
        }

        fmt.Print("row: ")
        for i, c := range cols {
            fmt.Printf("%s=%v ", c, values[i])
        }
        fmt.Println()
    }
    if err := rows.Err(); err != nil {
        log.Fatal(err)
    }
}

// PostgreSQL playground - Java example
// Requires PostgreSQL JDBC driver on classpath
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.ResultSetMetaData;

public class PgExample {
    public static void main(String[] args) throws Exception {
        String url = "jdbc:postgresql://exampledomain.org:5432/exampledb";
        String user = "playground";
        String pass = "playgroundpass";

        try (Connection conn = DriverManager.getConnection(url, user, pass);
             Statement st = conn.createStatement()) {

            // Initialize per-connection session
            st.execute("SELECT init_session();");

            // Query session-local customers
            try (ResultSet rs = st.executeQuery("SELECT * FROM customers LIMIT 10;")) {
                ResultSetMetaData meta = rs.getMetaData();
                int cols = meta.getColumnCount();

                while (rs.next()) {
                    StringBuilder sb = new StringBuilder("row: ");
                    for (int i = 1; i <= cols; i++) {
                        if (i > 1) sb.append(", ");
                        sb.append(meta.getColumnLabel(i))
                          .append("=")
                          .append(rs.getObject(i));
                    }
                    System.out.println(sb.toString());
                }
            }
        }
    }
}

# MySQL CLI
mysql -h exampledomain.org -P 3306 -u example -pexample shop

-- Example query
SELECT VERSION();
SELECT * FROM users LIMIT 5;

<?php
$dsn = "mysql:host=exampledomain.org;port=3306;dbname=shop;charset=utf8mb4";
$user = "example";
$pass = "example";

$pdo = new PDO($dsn, $user, $pass);
$stmt = $pdo->query("SELECT VERSION()");
echo $stmt->fetchColumn(), PHP_EOL;

# pip install pymongo
from pymongo import MongoClient

# Public playground Mongo:
# - host: exampledomain.org
# - port: 27017
# - db:   playground
# - user: playground
# - pass: playgroundpass
# Data is ephemeral and reset regularly.

client = MongoClient(
    "mongodb://playground:playgroundpass@exampledomain.org:27017/playground?authSource=admin"
)

db = client["playground"]
coll = db["customers"]

print("Initial customers:")
for doc in coll.find():
    print(doc)

coll.insert_one({"name": "Sandbox User", "email": "sandbox@example.com"})

print("After insert:")
for doc in coll.find():
    print(doc)

client.close()

// npm install mongodb
import { MongoClient } from "mongodb";

// Public playground Mongo:
// - host: exampledomain.org
// - port: 27017
// - db:   playground
// - user: playground
// - pass: playgroundpass
// Data is ephemeral and reset regularly.

const uri =
  "mongodb://playground:playgroundpass@exampledomain.org:27017/playground?authSource=admin";

const client = new MongoClient(uri);

async function main() {
  await client.connect();

  const db = client.db("playground");
  const coll = db.collection("customers");

  console.log("Initial customers:");
  console.log(await coll.find({}).toArray());

  await coll.insertOne({ name: "Sandbox User", email: "sandbox@example.com" });

  console.log("After insert:");
  console.log(await coll.find({}).toArray());

  await client.close();
}

main().catch(console.error);

// npm install ioredis
import Redis from "ioredis";

const redis = new Redis({
  host: "exampledomain.org",
  port: 6379,
});

async function run() {
  await redis.set("foo", "bar");
  const val = await redis.get("foo");
  console.log("foo =", val);
  await redis.quit();
}
run().catch(console.error);

// Cargo.toml dependency:
// redis = "0.24"
use redis::Commands;

fn main() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://exampledomain.org:6379/")?;
    let mut con = client.get_connection()?;
    con.set("foo", "bar")?;
    let val: String = con.get("foo")?;
    println!("foo = {}", val);
    Ok(())
}

// dotnet add package Microsoft.Data.SqlClient
using System;
using Microsoft.Data.SqlClient;

class Program
{
    static void Main()
    {
        var cs = "Server=exampledomain.org,1433;" +
                 "User Id=example;Password=example;Encrypt=False;";
        using var conn = new SqlConnection(cs);
        conn.Open();

        using var cmd = new SqlCommand("SELECT @@VERSION", conn);
        var version = cmd.ExecuteScalar();
        Console.WriteLine(version);
    }
}

// npm install mssql
import sql from "mssql";

const config = {
  user: "example",
  password: "example",
  server: "exampledomain.org",
  port: 1433,
  database: "master",
  options: {
    encrypt: false,
    trustServerCertificate: true,
  },
};

async function main() {
  const pool = await sql.connect(config);
  const result = await pool.request().query("SELECT @@VERSION");
  console.log(result.recordset[0]);
  await sql.close();
}
main().catch(console.error);

# pip install pika
import pika

creds = pika.PlainCredentials("example", "example")
params = pika.ConnectionParameters("exampledomain.org", 5672, "/", creds)
conn = pika.BlockingConnection(params)
chan = conn.channel()

chan.queue_declare(queue="demo")
chan.basic_publish(exchange="", routing_key="demo", body=b"hello from python")

print("Published message")
conn.close()

// npm install amqplib
import amqp from "amqplib";

async function main() {
  const conn = await amqp.connect({
    hostname: "exampledomain.org",
    port: 5672,
    username: "example",
    password: "example",
  });
  const ch = await conn.createChannel();
  const q = "demo";
  await ch.assertQueue(q);
  await ch.sendToQueue(q, Buffer.from("hello from node"));
  console.log("sent");
  await ch.close();
  await conn.close();
}
main().catch(console.error);

// go get github.com/rabbitmq/amqp091-go
package main

import (
  "log"
  "github.com/rabbitmq/amqp091-go"
)

func main() {
  url := "amqp://example:example@exampledomain.org:5672/"
  conn, err := amqp091.Dial(url)
  if err != nil {
    log.Fatal(err)
  }
  defer conn.Close()

  ch, err := conn.Channel()
  if err != nil {
    log.Fatal(err)
  }
  defer ch.Close()

  q, err := ch.QueueDeclare("demo", false, false, false, false, nil)
  if err != nil {
    log.Fatal(err)
  }

  body := "hello from go"
  if err := ch.Publish("", q.Name, false, false, amqp091.Publishing{
    ContentType: "text/plain",
    Body:        []byte(body),
  }); err != nil {
    log.Fatal(err)
  }
}

// npm install mqtt
import mqtt from "mqtt";

const client = mqtt.connect("mqtt://exampledomain.org:1883");

client.on("connect", () => {
  console.log("connected");
  client.subscribe("demo/topic");
  client.publish("demo/topic", "hello mqtt");
});

client.on("message", (topic, message) => {
  console.log(topic, "=", message.toString());
  client.end();
});

# pip install paho-mqtt
import time
import paho.mqtt.client as mqtt

client = mqtt.Client()

def on_connect(client, userdata, flags, rc):
    print("connected", rc)
    client.subscribe("demo/topic")
    client.publish("demo/topic", "hello from python")

def on_message(client, userdata, msg):
    print(msg.topic, "=", msg.payload.decode())
    client.disconnect()

client.on_connect = on_connect
client.on_message = on_message

client.connect("exampledomain.org", 1883, 60)
client.loop_forever()

# Get Ethereum node version
curl -X POST http://exampledomain.org:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"web3_clientVersion","params":[],"id":1}'

# Get current block number
curl -X POST http://exampledomain.org:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":2}'

// npm install node-fetch
import fetch from "node-fetch";

async function rpc(method, params = []) {
  const res = await fetch("http://exampledomain.org:8545", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method,
      params,
    }),
  });
  const data = await res.json();
  console.log(data);
}

await rpc("web3_clientVersion");
await rpc("eth_blockNumber");

# Simple HTTP GET
curl -v http://exampledomain.org:80/

# You should get 301 Moved Permanently (nginx/1.29.3)

# pip install requests
import requests

resp = requests.get("https://exampledomain.org/")
print(resp.status_code)
print(resp.text)

// npm install node-fetch
import fetch from "node-fetch";

const res = await fetch("https://exampledomain.org/");
console.log(res.status, await res.text());

# Basic Elasticsearch-style info
curl http://exampledomain.org:9200/

package main

import (
    "fmt"
    "log"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "exampledomain.org:1234")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    if _, err := fmt.Fprintln(conn, "hello echo"); err != nil {
        log.Fatal(err)
    }

    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("received: %s\n", string(buf[:n]))
}

use std::io::{Read, Write};
use std::net::TcpStream;

fn main() {
    let mut stream = TcpStream::connect("exampledomain.org:1234")
        .expect("connect failed");
    stream.write_all(b"hello echo\n").unwrap();

    let mut buf = [0u8; 1024];
    let n = stream.read(&mut buf).unwrap();
    println!("received: {}", String::from_utf8_lossy(&buf[..n]));
}

# Standard library only
import smtplib
from email.message import EmailMessage

msg = EmailMessage()
msg["From"] = "example@exampledomain.org"
msg["To"] = "demo@exampledomain.org"
msg["Subject"] = "Sandbox SMTP test"
msg.set_content("Hello from the dev examples SMTP sandbox.")

with smtplib.SMTP("exampledomain.org", 25, timeout=5) as s:
    s.login("example", "example")
    s.send_message(msg)
    print("Sent message")

// npm install nodemailer
import nodemailer from "nodemailer";

const transporter = nodemailer.createTransport({
  host: "exampledomain.org",
  port: 25,
  secure: false,
  auth: {
    user: "example",
    pass: "example",
  },
});

const info = await transporter.sendMail({
  from: "example@exampledomain.org",
  to: "demo@exampledomain.org",
  subject: "Sandbox SMTP test",
  text: "Hello from Node SMTP client",
});

console.log("Message sent:", info.messageId);

<?php
// Extremely minimal raw SMTP example (no TLS)
$socket = fsockopen("exampledomain.org", 25, $errno, $errstr, 5);
if (!$socket) {
    die("connect failed: $errstr\n");
}
fgets($socket); // banner

fputs($socket, "EHLO exampledomain.org\r\n");
echo fgets($socket);

fputs($socket, "AUTH LOGIN\r\n");
echo fgets($socket);

fputs($socket, base64_encode("example") . "\r\n");
echo fgets($socket);

fputs($socket, base64_encode("example") . "\r\n");
echo fgets($socket);

fputs($socket, "MAIL FROM:<example@exampledomain.org>\r\n");
echo fgets($socket);

fputs($socket, "RCPT TO:<demo@exampledomain.org>\r\n");
echo fgets($socket);

fputs($socket, "DATA\r\n");
echo fgets($socket);

fputs($socket, "Subject: Sandbox SMTP\r\n\r\nHello\r\n.\r\n");
echo fgets($socket);

fputs($socket, "QUIT\r\n");
fclose($socket);

# Plain-text IMAP (no TLS support here)
telnet exampledomain.org 143

a1 CAPABILITY

# Query LDAP rootDSE
ldapsearch -x -H ldap://exampledomain.org:389 \
  -s base -b "" "(objectClass=*)" \
  defaultNamingContext currentTime

# FTP
ftp exampledomain.org 21
# login: example / example

# or with curl
curl ftp://exampledomain.org/ --user example:example

# Standard library only
from ftplib import FTP

ftp = FTP()
ftp.connect("exampledomain.org", 21, timeout=5)
ftp.login("example", "example")
print(ftp.nlst())
ftp.quit()

# SSH
ssh -p 24 example@exampledomain.org
# password: example

# pip install paramiko
import paramiko

client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect("exampledomain.org", port=24, username="example", password="example")

stdin, stdout, stderr = client.exec_command("echo hello from ssh")
print(stdout.read().decode())
client.close()

# smbclient
smbclient -U example%example //exampledomain.org/public

# list files
ls

// npm install socks-proxy-agent node-fetch
import fetch from "node-fetch";
import { SocksProxyAgent } from "socks-proxy-agent";

const agent = new SocksProxyAgent("socks5://example:example@exampledomain.org:1080");

const res = await fetch("http://www.bing.com", { agent });
console.log("Status:", res.status);