Pekka Alaluukas /Docker

Docker

MySQL Dockerin sisällä

Tämä esimerkki näyttää, kuinka MySQL-palvelinta ajetaan kontin sisällä. Tässä tapauksessa sinun ei tarvitse luoda omaa Dockerfilea, koska virallinen mysql-image on jo saatavilla Docker Hubissa. Imagen ylläpitää MySQL-tiimi ja se sisältää kaiken esikonfiguroidun MySQL-palvelimen ajamiseksi.

Voit ladata MySQL-imagen Docker Hubista ja käynnistää kontin alla olevilla komennoilla

docker pull mysql:8.1
docker run --name docker_mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 -d mysql:8.1

Sitten voit yhdistää MySQL:ään alla olevalla komennolla

docker exec -it docker_mysql mysql -u root -p

Composen käyttö

MySQL-konttia luotaessa Docker Composea käytetään usein, koska se helpottaa asetuksia ja hallintaa. Sen sijaan, että kirjoittaisit pitkiä docker run -komentoja monilla vaihtoehdoilla (kuten portit, volyymit ja ympäristömuuttujat), Compose antaa sinun määrittää kaiken yksinkertaisessa docker-compose.yml-tiedostossa. Tämä tekee konfiguraatiosta selkeän, uudelleenkäytettävän ja helposti jaettavan. Se myös mahdollistaa MySQL:n (ja muiden liittyvien palveluiden, kuten sovelluskontin) käynnistämisen, pysäyttämisen ja hallinnan yhdellä komennolla.

Käynnistä Docker Desktop
Luo sitten kansio nimeltä mysql

Luo tiedosto nimeltä docker-compose.yml mysql-kansion sisälle alla olevalla koodilla

services:
  db:
    image: mysql:latest          # Käytä uusinta virallista MySQL-imagea Docker Hubista
    container_name: docker_mysql # Kontin nimi helpompaa viittaamista varten
    restart: always              # Varmistaa, että kontti käynnistyy automaattisesti, jos se pysähtyy
    environment:
      MYSQL_DATABASE: netdb      # Luo tietokannan nimeltä "netdb" kontin käynnistyessä
      MYSQL_ROOT_PASSWORD: root  # Asettaa root-salasanan MySQL:lle (pitäisi olla vahvempi tuotannossa)
    ports:
      - "3306:3306"              # Yhdistää isäntäkoneen portin 3306 kontin porttiin 3306 (MySQL:n oletusportti)
    volumes:
      - my-db:/var/lib/mysql     # Säilyttää tietokannan datan isäntäkoneella nimetyn volyymin kautta

volumes:
  my-db:                         # Määrittää nimetyn volyymin "my-db", jota käytetään pysyvään tallennukseen

Avaa pääte mysql-kansion sisällä ja suorita komento
```
docker compose up --build
```
Voit yhdistää MySQL:ään kontista
```
docker exec -it docker_mysql mysql -u root -D netdb -p
```
Root-salasana on root (tarkista yml-tiedosto)
Jos sinulla on mysql-client tietokoneellasi, voit yhdistää myös komennolla
```
mysql -h 127.0.0.1 -P 3306 -u root -p
```

PostgreSQL Dockerin sisällä

Tämä esimerkki näyttää, kuinka PostgreSQL-palvelinta ajetaan kontin sisällä.

Käynnistä Docker Desktop
Lataa PostgreSQL image
```
docker pull postgres:16
```

Käynnistä kontti

docker run --name docker_postgres -e POSTGRES_PASSWORD=root -p 5432:5432  -d postgres:16

Avaa yhteys

docker exec -it docker_postgres psql -U postgres

Composen käyttö

Tässä esimerkissä luodaan Composen avulla PostgreSQL palvelin ja siihen tietokanta nimeltään netdb.

Käynnistä Docker Desktop
Luo sitten kansio nimeltä postgres

Luo tiedosto nimeltä docker-compose.yml postgres-kansion sisälle alla olevalla koodilla

services:
  db:
    image: postgres:16
    container_name: docker_postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: netuser
      POSTGRES_PASSWORD: netpass
      POSTGRES_DB: netdb
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Avaa pääte postgres-kansion sisällä ja suorita komento
```
docker-compose up -d
```

Voit yhdistää PostgreSQL:ään kontista

docker exec -it docker_postgres psql -U netuser -d netdb

Node.js+MySQL esimerkki

Tämä esimerkki näyttää, kuinka luodaan Dockerfile ja ajetaan express.js-sovellusta ja MysQL-palvelinta Dockerin sisällä.

Luo uusi kansio nimeltä docker_express
Avaa pääte docker_express-kansion sisällä ja suorita alla olevat komennot
```
npm init
npm install express
```

luo tiedosto nimeltä app.js alla olevalla koodilla

const express = require('express');

const PORT = 3000;
const HOST = '0.0.0.0';

const app = express();
app.get('/', function(req, res) {
  res.send('Server is running!');
});

app.get('/:fname', function(req, res){
  res.send('Hello '+req.params.fname);
});

app.listen(PORT, HOST, function() {
  console.log(`Running on http://${HOST}:${PORT}`);
});

Muokkaa tiedostoa package-json, niin että se näyttää alla olevalta

{
  "name": "express",
  "version": "1.0.0",
  "description": "",
  "license": "ISC",
  "author": "",
  "type": "commonjs",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^5.1.0",
    "mysql2": "^3.3.2",
    "dotenv": "^16.3.1"
  }
}

Dockerfile

Luo tiedosto nimeltä Dockerfile alla olevalla koodilla

FROM node:20

# Aseta työskentelyhakemisto kontin sisälle
WORKDIR /usr/src/app

# Kopioi ensin vain package.json ja package-lock.json
COPY package*.json ./

# Asenna projektin riippuvuudet
RUN npm install

# Kopioi loput sovelluksen koodista
COPY . .

# Paljasta portti, jolla sovellus toimii
EXPOSE 3000

# Oletuskomento tuotantoon
CMD ["npm", "start"]

Luo tiedosto nimeltä .dockerignore alla olevilla riveillä
```
node_modules/
npm-debug.log
```

Docker Compose

Luo tiedosto nimeltä docker-compose.yml alla olevalla koodilla

services:
  app:
    build: .
    container_name: express_app
    ports:
      - "3000:3000"
    restart: always
    environment:
      NODE_ENV: production 

  db:
    image: mysql:latest          # Käytä uusinta virallista MySQL-imagea Docker Hubista
    container_name: docker_mysql # Kontin nimi helpompaa viittaamista varten
    restart: always              # Varmistaa, että kontti käynnistyy automaattisesti, jos se pysähtyy
    environment:
      MYSQL_DATABASE: netdb      # Luo tietokannan nimeltä "netdb" kontin käynnistyessä
      MYSQL_ROOT_PASSWORD: root  # Asettaa root-salasanan MySQL:lle (pitäisi olla vahvempi tuotannossa)
      MYSQL_ROOT_HOST: "%"        # ➜ Sallii root-kirjautumisen mistä tahansa hostista
    ports:
      - "3306:3306"              # Yhdistää isäntäkoneen portin 3306 kontin porttiin 3306 (MySQL:n oletusportti)
    volumes:
      - my-db:/var/lib/mysql      # Tietokantadata säilytetään konttien ulkopuolella Dockerin luomassa nimetyssä volyymissä

volumes:
  my-db:                         # Määrittää nimetyn volyymin "my-db", jota käytetään pysyvään tallennukseen

Suorita komento
```
docker-compose up --build
```
Nyt kontin pitäisi olla käynnissä
Kokeile selaimella osoitteessa http://localhost:3000
Kokeile kirjautua MySQL-tietokantaan

Nodemon

Jos haluat muokata koodiasi ja nähdä muutokset, sinun täytyy poistaa image ja kontti. Joten se on hyvin hidasta. Joten voit käyttää nodemonia node.js-sovelluksen käynnistämiseen. Nodemon tarkkailee js-tiedostoja, ja jos ne muuttuvat, sovellus käynnistyy uudelleen.

Poista kontti komennolla
```
  docker-compose down -v
```

Korvaa package.json alla olevalla koodilla

{
  "name": "express",
  "version": "1.0.0",
  "description": "",
  "license": "ISC",
  "author": "",
  "type": "commonjs",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "dev": "nodemon app.js"
  },
  "dependencies": {
    "express": "^5.1.0",
    "mysql2": "^3.3.2",
    "dotenv": "^16.3.1"
  },
  "devDependencies": {
    "nodemon": "^2.0.22"
  }
}

Muokkaa Dockerfilea niin, että RUN-komento on
```
RUN npm install && npm install nodemon -g
```

Lisää tiedosto nimeltä docker-compose.override.yml alla olevalla koodilla

services:
  app:
    command: npm run dev        # tai index.js — käytä projektisi entrypointia
    environment:
      NODE_ENV: development              # override: dev-tila
    volumes:
      - .:/usr/src/app                   # mounttaa projektin konttiin
      - /usr/src/app/node_modules        # estää node_modulesin ylikirjoituksen

Lisää tiedosto nodemon.json seuraavalla koodilla

  {
  "watch": ["."],
  "ext": "js,json",
  "ignore": ["node_modules"],
  "legacyWatch": true,
  "verbose": true
}

Käynnistä kontti ja muokkaa tiedostoa app.js. Sinun pitäisi nähdä muutokset verkkosivustolla.

Nyt kehityksessä voit käynnistää kontin alla olevalla komennolla

docker-compose up --build

Ja tuotannossa voit käynnistää kontin alla olevalla komennolla

docker compose -f docker-compose.yml up --build

Toggle Menu

Pekka Alaluukas 2025