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.

1. Käynnistä Docker Desktop
2. Lataa PostgreSQL image

   docker pull postgres:16
   

3. Käynnistä kontti

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

4. Avaa yhteys

   docker exec -it docker_postgres psql -U postgres
   

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

docker exec -it docker_mysql mysql -u root -p

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

1. Käynnistä Docker Desktop
2. Luo sitten kansio nimeltä postgres
3. 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ä');
   

4. 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:
   

5. 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.
6. 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.
7. 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.
8. Avaa pääte postgres-kansion sisällä ja suorita komento

   docker-compose up -d
   

9. Voit avata kontin psql-asiakasohjelmalla yhteyden netdb-tietokantaan

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

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.

1. Käynnistä Docker Desktop
2. Luo sitten kansio nimeltä mysql
3. 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ä');
   

4. 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
   

5. 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.
6. 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"
   

7. Avaa pääte mysql-kansion sisällä ja suorita komento

   docker compose up --build
   

8. Voit yhdistää MySQL:ään kontista

   docker exec -it docker_mysql mysql -u root -D netdb -p
   

   Root-salasana on root (tarkista yml-tiedosto)
9. Jos sinulla on mysql-client tietokoneellasi, voit yhdistää myös komennolla

   mysql -h 127.0.0.1 -P 3306 -u root -p
   

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.

1. Luo uusi kansio nimeltä docker_express
2. Avaa pääte docker_express-kansion sisällä ja suorita alla olevat komennot

   npm init
   npm install express
   

3. 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}`);
   });
   

4. 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"
     }
   }
   

docker-compose up --build

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

Toggle Menu