Pekka Alaluukas /Docker

Docker

PostgreSQL Docker Hubin avulla

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

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

MySQL Docker Hubin avulla

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

PostgreSQL Composen avulla

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

Käynnistä Docker Desktop
Luo sitten kansio nimeltä postgres
Luo postgres-kansion sisälle kansio nimeltä api ja sen sisälle tiedosto nimeltä init.sql. Tiedostoon voit lisätä tietokannan alustuksessa suoritettavat SQL-komennot, esimerkiksi
```
CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL
);

INSERT INTO users (name) VALUES ('Testikäyttäjä');
```

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:
      - postgres_data:/var/lib/postgresql/data
      - ./api/init.sql:/docker-entrypoint-initdb.d/init.sql:ro

volumes:
  postgres_data:

init.sql liitetään konttiin kirjoitussuojattuna (ro). PostgreSQL suorittaa /docker-entrypoint-initdb.d-kansiossa olevat SQL-tiedostot automaattisesti, kun tietokanta alustetaan ensimmäisen kerran. Skriptiä ei suoriteta uudelleen, jos postgres_data-volyymissa on jo tietokannan dataa.
postgres_data on nimetty Docker-volyymi, jossa tietokannan data säilyy, vaikka kontti pysäytetään tai poistetaan. Esimerkiksi docker compose down ei poista volyymia. Volyymi ja kaikki siinä oleva tietokantadata poistetaan, jos suoritat komennon
```
docker compose down -v
```
Volyymin voi poistaa myös erikseen Dockerin volume-komennoilla tai Docker Desktopissa. Huomaa, että volyymin poistaminen hävittää tietokannan tiedot pysyvästi.
Jos muokkaat init.sql-tiedostoa myöhemmin, valitse tilanteeseen sopiva tapa:
- Kehitysympäristössä voit luoda tietokannan kokonaan uudelleen komennoilla
```
docker compose down -v
docker compose up -d
```
  Uusi volyymi luodaan ja päivitetty init.sql suoritetaan automaattisesti. Kaikki vanha tietokantadata menetetään.
- Jos olemassa oleva data halutaan säilyttää, tee muutoksista erillinen migraatio tai varmista, että SQL-komennot voidaan suorittaa turvallisesti useita kertoja. Päivitetyn tiedoston voi suorittaa käynnissä olevaan tietokantaan komennolla
```
docker exec -it docker_postgres psql -U netuser -d netdb -f /docker-entrypoint-initdb.d/init.sql
```
  Tällöin PostgreSQL ei kuitenkaan suorita tiedostoa alustusskriptinä, vaan tavallisena SQL-skriptinä olemassa olevaan tietokantaan.
Avaa pääte postgres-kansion sisällä ja suorita komento
```
docker-compose up -d
```
Voit avata kontin psql-asiakasohjelmalla yhteyden netdb-tietokantaan
```
docker exec -it docker_postgres psql -U netuser -d netdb
```

MySQL Composen avulla

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 mysql-kansion sisälle kansio nimeltä api ja sen sisälle tiedosto nimeltä init.sql. Tiedostoon voit lisätä tietokannan alustuksessa suoritettavat SQL-komennot, esimerkiksi
```
CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(100) NOT NULL
);

INSERT INTO users (name) VALUES ('Testikäyttäjä');
```

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
      - ./api/init.sql:/docker-entrypoint-initdb.d/init.sql:ro

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

init.sql liitetään konttiin kirjoitussuojattuna (ro). MySQL suorittaa /docker-entrypoint-initdb.d-kansiossa olevat SQL-tiedostot automaattisesti vain silloin, kun tietokanta alustetaan tyhjään my-db-volyymiin ensimmäisen kerran.
Jos muokkaat init.sql-tiedostoa myöhemmin ja haluat alustaa tietokannan kokonaan uudelleen, suorita
```
docker compose down -v
docker compose up -d
```
Tämä poistaa volyymin ja kaiken vanhan tietokantadatan. Jos data halutaan säilyttää, tee muutoksista erillinen migraatio tai varmista, että SQL-komennot voidaan suorittaa turvallisesti useita kertoja. Päivitetyn tiedoston voi suorittaa olemassa olevaan tietokantaan komennolla
```
docker exec -it docker_mysql mysql -u root -p netdb -e "source /docker-entrypoint-initdb.d/init.sql"
```
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
```

Node.js+MySQL esimerkki

Tämä esimerkki näyttää, kuinka luodaan Dockerfile ja ajetaan Express.js-sovellusta ja MySQL-palvelinta Docker-konteissa.

Esimerkissä tarvitaan sekä Dockerfile että Docker Compose, koska niillä on eri tehtävät:

Dockerfile sisältää ohjeet Node.js-sovelluksen oman imagen rakentamiseen. Se määrittää esimerkiksi Node.js-version, työskentelyhakemiston, riippuvuuksien asentamisen, sovelluskoodin kopioinnin ja käynnistyskomennon.
Docker Compose määrittää, miten sovelluskontti ja MySQL-kontti käynnistetään ja toimivat yhdessä. Sen avulla määritetään esimerkiksi palvelut, portit, ympäristömuuttujat ja tietokannan volyymi.

Compose-tiedoston sovelluspalvelun build: . pyytää Composea rakentamaan sovellusimagen nykyisen kansion Dockerfilen avulla. MySQL-palvelulle omaa Dockerfilea ei tarvita, koska Compose lataa sille valmiin virallisen mysql-imagen. Molemmat palvelut voidaan sen jälkeen rakentaa ja käynnistää yhdellä Compose-komennolla.

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

Compose Watch

Kehitystyössä voit käyttää Compose Watchia: Compose tarkkailee paikallisia tiedostoja, kopioi koodimuutokset konttiin ja käynnistää kontin uudelleen. Tavalliset koodimuutokset eivät vaadi imagen rakentamista tai poistamista. Riippuvuuksien tai Dockerfilen muuttuessa Compose rakentaa imagen uudelleen ja luo sovelluskontin uudelleen.

Tässä käytetty sync+restart-toiminto edellyttää Docker Compose -versiota 2.23.0 tai uudempaa. Tarkista versio komennolla docker compose version. Pelkkä sync kopioisi tiedostot konttiin, mutta ei käynnistäisi tätä Express-sovellusta uudelleen.

Säilytä edellä esitetyt package.json, Dockerfile ja .dockerignore. Sovellus käynnistyy edelleen komennolla npm start.

Luo projektin juureen tiedosto docker-compose.override.yml alla olevalla sisällöllä.

services:
  app:
    environment:
      NODE_ENV: development
    develop:
      watch:
        - action: sync+restart
          path: .
          target: /usr/src/app
          ignore:
            - node_modules/
            - package.json
            - package-lock.json
            - Dockerfile
            - .dockerignore
            - docker-compose*.yml
        - action: rebuild
          path: package.json
        - action: rebuild
          path: package-lock.json
        - action: rebuild
          path: Dockerfile
        - action: rebuild
          path: .dockerignore

Käynnistä kehitysympäristö ja tiedostojen tarkkailu komennolla
```
docker compose up --build --watch
```
Muokkaa ja tallenna app.js. Compose kopioi muutoksen konttiin ja käynnistää sovelluskontin uudelleen. Päivitä selain osoitteessa http://localhost:3000, jotta näet muutoksen.

node_modules-hakemistoa ei kopioida paikalliselta koneelta konttiin, vaan riippuvuudet asennetaan Dockerfilen avulla. Kun package.json tai package-lock.json muuttuu, rebuild-sääntö varmistaa, että riippuvuudet asennetaan uudelleen. Jos muutat Compose-tiedostoja, lopeta tarkkailu painamalla Ctrl+C ja suorita käynnistyskomento uudelleen.

Tätä työnkulkua varten ei tarvitse suorittaa docker compose down -v -komentoa. Sen -v-valitsin poistaisi myös esimerkin MySQL-tietokannan nimetyn datavolyymin.

Tuotannossa käynnistä sovellus komennolla

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

Valitsimella -f docker-compose.yml varmistetaan, ettei Compose lataa kehityskäyttöön tarkoitettua docker-compose.override.yml-tiedostoa automaattisesti. Tuotannossa NODE_ENV säilyy arvossa production, tiedostoja ei tarkkailla ja sovellus käyttää imageen rakentamisen aikana kopioitua koodia.

Nodemon on vaihtoehto, jos haluat käynnistää uudelleen vain Node.js-prosessin kontin sisällä tai käyttää samaa kehitystapaa myös ilman Dockeria. Tässä esimerkissä Compose Watch hoitaa tiedostojen tarkkailun ja kontin uudelleenkäynnistyksen, joten Nodemonia ei tarvita. Lisätietoja: Dockerin Compose Watch -ohje.

Toggle Menu

Pekka Alaluukas 2025