# Start an Ubuntu container interactively
docker run -it --name test-container ubuntu bash

# Inside the container - create a file with important data
echo "This is important data - will it survive?" > /tmp/mydata.txt
echo "Record 1: Alice" >> /tmp/mydata.txt
echo "Record 2: Bob" >> /tmp/mydata.txt

# Verify the file exists
cat /tmp/mydata.txt

# Expected output:
This is important data - will it survive?
Record 1: Alice
Record 2: Bob

# Exit the container
exit

# Delete the container
docker rm test-container

# Start a brand new Ubuntu container
docker run -it --name test-container-2 ubuntu bash

# Try to read the file - it's GONE!
cat /tmp/mydata.txt

# Expected output (ERROR):
cat: /tmp/mydata.txt: No such file or directory

# Data is permanently lost! Exit and cleanup
exit
docker rm test-container-2

# Create a named volume for MySQL data
docker volume create mysql-data

# Verify it was created
docker volume ls

# Expected output:
DRIVER    VOLUME NAME
local     mysql-data

# Inspect the volume - see where Docker stores it
docker volume inspect mysql-data

# Expected output:
[
    {
        "CreatedAt": "2026-06-16T...",
        "Driver": "local",
        "Mountpoint": "/var/lib/docker/volumes/mysql-data/_data",
        "Name": "mysql-data",
        "Scope": "local"
    }
]

# Run MySQL with the named volume attached to its data directory
docker run -d \
  --name my-mysql \
  -v mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=MySecret123 \
  -e MYSQL_DATABASE=testdb \
  -p 3306:3306 \
  mysql:8.0

# Wait 20 seconds for MySQL to fully initialize
sleep 20

# Verify container is running
docker ps

# Check MySQL startup logs
docker logs my-mysql --tail 5

# Connect to MySQL inside the container
docker exec -it my-mysql mysql -u root -pMySecret123

-- Switch to our test database
USE testdb;

-- Create a users table
CREATE TABLE users (
  id         INT AUTO_INCREMENT PRIMARY KEY,
  name       VARCHAR(100),
  email      VARCHAR(100),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Insert test records
INSERT INTO users (name, email) VALUES
  ('Alice Johnson', 'alice@example.com'),
  ('Bob Smith',     'bob@example.com'),
  ('Charlie Brown', 'charlie@example.com');

-- Verify data was inserted
SELECT * FROM users;

-- Expected output:
+----+---------------+---------------------+---------------------+
| id | name          | email               | created_at          |
+----+---------------+---------------------+---------------------+
|  1 | Alice Johnson | alice@example.com   | 2026-06-16 ...      |
|  2 | Bob Smith     | bob@example.com     | 2026-06-16 ...      |
|  3 | Charlie Brown | charlie@example.com | 2026-06-16 ...      |
+----+---------------+---------------------+---------------------+

EXIT;

# Force delete the MySQL container
docker rm -f my-mysql

# Verify container is gone
docker ps -a

# But check - the VOLUME still exists!
docker volume ls

# Expected output - volume is still there:
DRIVER    VOLUME NAME
local     mysql-data   <-- Still exists! Data is safe!

# Start a NEW MySQL container with the SAME volume
docker run -d \
  --name my-mysql-v2 \
  -v mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=MySecret123 \
  -p 3306:3306 \
  mysql:8.0

# Wait for MySQL to start
sleep 20

# Connect and check if data survived!
docker exec -it my-mysql-v2 mysql -u root -pMySecret123

USE testdb;
SELECT * FROM users;

-- ALL DATA IS BACK! Volume worked perfectly!
+----+---------------+---------------------+---------------------+
| id | name          | email               | created_at          |
+----+---------------+---------------------+---------------------+
|  1 | Alice Johnson | alice@example.com   | 2026-06-16 ...      |
|  2 | Bob Smith     | bob@example.com     | 2026-06-16 ...      |
|  3 | Charlie Brown | charlie@example.com | 2026-06-16 ...      |
+----+---------------+---------------------+---------------------+

EXIT;

# Cleanup
docker rm -f my-mysql-v2

# Create project directory on your HOST machine
mkdir ~/docker-bind-demo
cd ~/docker-bind-demo

# Create a simple Node.js HTTP server
cat > app.js << 'EOF'
const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end('
Hello from Docker Bind Mount!
Version 1.0
');
});
server.listen(3000, () => console.log('Server running on port 3000'));
EOF

# Create package.json
cat > package.json << 'EOF'
{
  "name": "bind-mount-demo",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": { "start": "node app.js" }
}
EOF

# Verify files are created
ls -la

# Run Node.js container with bind mount
# $(pwd) = current directory on your host machine
# /app   = where it appears inside the container
docker run -d \
  --name node-app \
  -v $(pwd):/app \
  -w /app \
  -p 3000:3000 \
  node:18 node app.js

# Test the app
curl http://localhost:3000

# Expected output:
Hello from Docker Bind Mount!
Version 1.0

# Edit app.js on your HOST machine
cat > ~/docker-bind-demo/app.js << 'EOF'
const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end('
UPDATED! Bind Mount Works!
Version 2.0 - No rebuild!
');
});
server.listen(3000, () => console.log('Server v2.0 running'));
EOF

# Restart the container to pick up changes
docker restart node-app

# Test again - new version is live!
curl http://localhost:3000

# Expected output:
UPDATED! Bind Mount Works!
Version 2.0 - No rebuild!

# Cleanup
docker rm -f node-app

# Run container with tmpfs mount at /app/temp (100MB RAM)
docker run -d \
  --name tmpfs-demo \
  --tmpfs /app/temp:rw,size=100m \
  ubuntu sleep 3600

# Write sensitive data to the tmpfs mount
docker exec tmpfs-demo bash -c \
  "echo 'SECRET_TOKEN=abc123xyz987' > /app/temp/session.txt"

# Read the data - it's there!
docker exec tmpfs-demo cat /app/temp/session.txt

# Expected output:
SECRET_TOKEN=abc123xyz987

# Verify it's stored in RAM (not on disk)
docker exec tmpfs-demo df -h /app/temp

# Expected output (shows tmpfs filesystem):
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           100M  4.0K  100M   1% /app/temp

# Stop the container
docker stop tmpfs-demo

# Start it again
docker start tmpfs-demo

# Try to read the file - it's GONE (expected behavior!)
docker exec tmpfs-demo cat /app/temp/session.txt

# Expected output:
cat: /app/temp/session.txt: No such file or directory
# This is CORRECT - tmpfs data is intentionally temporary!

# Cleanup
docker rm -f tmpfs-demo

# Create project directory
mkdir ~/wordpress-demo && cd ~/wordpress-demo

# Create docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:

  db:
    image: mysql:8.0
    container_name: wordpress-db
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword123
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wppassword123
    volumes:
      - mysql-data:/var/lib/mysql       # Named volume for DB
    networks:
      - wp-network

  wordpress:
    image: wordpress:latest
    container_name: wordpress-app
    restart: always
    depends_on:
      - db
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wppassword123
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wp-content:/var/www/html/wp-content              # Named volume
      - ./themes:/var/www/html/wp-content/themes/custom  # Bind mount
    networks:
      - wp-network

volumes:
  mysql-data:
    driver: local
  wp-content:
    driver: local

networks:
  wp-network:
    driver: bridge
EOF

# Start all services in background
docker compose up -d

# Check all containers are running
docker compose ps

# Expected output:
NAME             IMAGE         STATUS          PORTS
wordpress-db     mysql:8.0     Up 30 seconds   3306/tcp
wordpress-app    wordpress     Up 25 seconds   0.0.0.0:8080->80/tcp

# List volumes created by compose
docker volume ls

# Expected output:
DRIVER    VOLUME NAME
local     wordpress-demo_mysql-data
local     wordpress-demo_wp-content

# Visit WordPress: http://localhost:8080

# Stop containers - volumes are KEPT!
docker compose down

# Restart - all data is still there!
docker compose up -d

# To remove EVERYTHING including volumes (careful!):
docker compose down -v