Mihin Docker tarvitaan

Ensimmäisen kerran kuulin Docker:ista vuosi sitten ”Linux – Keskitetty hallinta” kurssilla. Silloin opettajamme käynnisti kilpailun, kuka osaisi käynnistää mahdollisemmin paljon koneita käyttäen Puppet keskitetty hallinta instrumenttia ja PXE:ta . Parin viikon aikana opettaja oli julkaissut tulokset missä onnistuttiin käynnistämään kaikki Labra-luokan koneet, sitten tämän ennätyksen rikottiin käynnistämällä yli 50 virtuaalikoneetta. Kilpailun voittaja onnistui käynnistämään kahdella läppärillä yhdistettynä yhteen verkkoon yli 400 Docker konteineria. Tämä yllättävän iso tulos sai minut tutustumaan Dockeriin ensimmäisen kerran. Parina iltana olin tutustunut konteineri teknologiaan ja miten saa käynnistettyä yksittäisiä Docker konteinereita.

Seuraavan kerran törmäsin Dockeriin, kun Ohjelmistoprojekti kurssin opettaja järjesti meille vierailuluennon mihin tuli ohjelmisto yrityksen edustaja kertomaan meille Docker käytöstä omassa toiminnassa. Silloin ymmärsin, että Docker on hyvä työkalu myös ohjelmistokehitykseen varsinkin, jos työryhmän jäsenet käyttävät erilaiset työympäristöt. Viime aikoina yleistynyt käytäntö ”Bring your own device (BYOD)” tekee hankalaksi saada työympäristöt identtiseksi, niin että samaa koodi yhdellä koneella toimisi samalla tavalla, kun toisella. Meille näytettiin, miten helppoa on saada kasaan koodia Docker konteineriin ja riippumatta siitä käyttäkö Linux, Mac tai Windows käyttöjärjestelmää konteinerissa koodi tulee toimimaan samalla tavalla.

Konteinerin voi vertailla hiekkalaatikkoon, koska mikään sovellus sen sisältä ei voi päästä isäntä koneen eikä muiden konteinerin prosesseihin itsestään. Jos konteineri kaapataan tai se saastuu viruksella, se ei aiheuta suuria ongelmia, niin kun jos sovellus olisi pyörinyt tavallisella koneella. Konteinerit voidaan sammuttaa ja luoda uudet muutamassa minuutissa. Konteinerit voidaan säilyttää DockerHub nimisessä varastossa ja käynnistää ne missä tahansa koneessa. Suurimmat pilvipalvelujen tarjoajat kuten Azure, AWS, Digital Ocean, Docker Cloud tarjoavat tukea docker konteinerille.

Docker ei käytä vierasta käyttöjärjestelmää vaan host koneen omaa käyttöjärjestelmää. Sen takia Docker on nopeampi, kun virtuaalikoneet. Sen mahdollistaa libcontainer joka antaa mahdollisuuden käyttää isäntä koneen resursseja. AuFS tiedostojärjestelmä joka eristää isäntäkoneen tiedostot konteinerista. Tässä kuitenkin on mainittava, että virtuaalinen kone on turvallisempi kun konteineri koska käyttää täysin eristettyjä komponenttia, mutta konteinerin nopeus ja vaatimattomuus tekevät siitä suositun joissakin tehtävissä.

Cloud Services kurssilla vierailuluennoitsija Microsoftin sovellusarkkitehti Janne Hansen oli kertonut meille että konteinerit pystyy helposti käynnistämään Azure platformilla ja Jouko Ruuskanen IBM:stä suositteli konteinereille Bluemix alustan, mutta varoitti käyttämästään konteinerit tietokantojen pyörittämiseen. Hänen mukaan konteinerit eivät sovi tähän, koska jos konteinerille tapahtuu joitain, niin koko tietokanta voi katoa. Sen sijaan mikropalvelujen (microservices) käyttämiseen konteinerit sopivat mainiosti.

Docker asennus Ubuntu 16.04:lle

Asennetaan tarvittavat ohjelmat, avaimet:

$ sudo apt-get -y install \ apt-transport-https \ ca-certificates \ curl

Tulen tarvitsemaan python, pip ja java, niin tarkistan näiden pakettien versiot ja jos joku puuttuu, niin asennan sen:
$ python --version Python 2.7.12 $ pip --version pip 8.1.1 from /usr/lib/python2.7/dist-packages (python 2.7) $ java -version openjdk version "1.8.0_111" OpenJDK Runtime Environment (build 1.8.0_111-8u111-b14-2ubuntu0.16.04.2-b14) OpenJDK 64-Bit Server VM (build 25.111-b14, mixed mode)
Docker lisätään repositoorin käynnistämällä scriptin tästä paikasta https://get.docker.com/ , sieltä löytyvät myös ohjeet, pitää ladata avaimet ja tarkista ne pip:lla.

Ubuntu:lle löytyvät vielä tällaiset ohjeet:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - $ sudo add-apt-repository \ "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) \ stable" $ sudo apt-get update

Assenetaan Docker Community Edition:

$ sudo apt-get -y install docker-ce

Käynnistetään Hello Wold dockerilla:

$ sudo docker run hello-world

Jos kaikki on asennettu oikein, ruudulle ilmestyy seuraavaa:

$ docker run hello-world

Hello from Docker!

This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:

The Docker client contacted the Docker daemon.
The Docker daemon pulled the “hello-world” image from the Docker Hub.
The Docker daemon created a new container from that image which runs the

executable that produces the output you are currently reading.

The Docker daemon streamed that output to the Docker client, which sent it

to your terminal.

To try something more ambitious, you can run an Ubuntu container with:

$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker Hub account:

https://hub.docker.com

For more examples and ideas, visit:

https://docs.docker.com/engine/userguide/

Kokeilen käynnistää joku image dockerilla:

$ docker run busybox

Ruudulla ei näkynyt mitään muutoksia, koska docker konteinerissa ei ollut mitään jatkuvaa toimintaa, se oli sammuttu. Käynnissä olevat containerit voi tarkistaa seuraavalla komennolla:
$ docker ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

Luettelo on tyhjä koska nyt ei ole yhtään käynnissä olevaa conteineria. Katsotaan toisella komennolla mitkä containerit oli käynnistetty aikaisemmin:

user@hp:~$ docker ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

9b70ae23c590 busybox “sh” 3 minutes ago Exited (0) 3 minutes ago lucid_swirles

cf4709ef0645 busybox “sh” 3 minutes ago Exited (0) 3 minutes ago brave_curran

0ed78d5dab10 hello-world “/hello” 15 minutes ago Exited (0) 15 minutes ago loving_leavitt

Sarakkeessa Status näkee koska containerit lopettivat toimintansa. Sarakkeessa Image näkee mistä imagesta container oli luotu ja sarakkeessa Command näkee mitä komentoja oli silloin annettu.

Kun käynnistetään dockerilla joku container, niin ohjelma luo uuden containerin joka säilyy levyllä ja vie sen tilan. Sen takia pitää muistaa poistaa ne, kun niitä ei tarvita enää. Container ID sarakkeessa on containerin tunnus millä voidaan ylläpitämään containerin. Containerille annetaan myös nimen, joka voidaan käyttää ylläpidossa.

Poistetaan joku vanhoista containerista nimellä:

$ docker rm loving_leavitt loving_leavitt

Poistetaan joku vanhoista containerista ID:llä:

$ docker rm cf4709ef0645

cf4709ef0645

Oikeastaan tämä 12 merkkiä pitkää heksadesimaaliluku on vain konteinerin ID:n alku osaa, mutta se riittää ylläpitoon. Kokonaisen luvun voi nähdä, kun kirjoittaa alkunumerot ja painaa Tab näppäintä, niin konteinerin tunnus tulee ruudulle kokonaisena. Versiosta 1.10 konteinerin numero on sen allekirjoitus SHA256 salausmenetelmällä.

$ docker rm 9b70ae23c590d436daa2a2c62427ae19e5fd599d77c952202c6493a62a4fa44c

9b70ae23c590d436daa2a2c62427ae19e5fd599d77c952202c6493a62a4fa44c

Konteinerin voidaan poistaa myös ryhmässä, esimerkiksi kaikki mitkä lopettivat toimintansa.

$ docker rm $(docker ps -a -q -f status=exited)

2088b7435cd5

4da4e0395bfe

2a65d3c719b8

48586b58786e

Kaikki imaget lokaalirepositorilla saa näkyviin komennolla:

user@hp:~$ docker images

REPOSITORY TAG IMAGE ID CREATED SIZE

busybox latest 00f017a8c2a6 4 weeks ago 1.11 MB

baseimage-ssh latest c3cab77fad14 3 months ago 226 MB

wordpress latest d3914bbdf814 4 months ago 399 MB

ubuntu latest 82e3ed0fbd96 4 months ago 128 MB

phusion/baseimage latest 0abfbf967cf9 9 months ago 226 MB

hello-world latest 723aa7d39e9d 9 months ago 1.85 kB

Imaget laadataan lokaalirepositoorille kommennolla:

$ docker pull imagen_nimi

BusyBox:lla pystyy kirjoittamaan echo viestin:

$ docker run busybox echo "Hello World form docker"

Hello World from docker

Pystyy käynnistämään tty ja katsomaan containerin sisältöä:

$ docker run -it busybox sh

Linux pohjaisissa konteinerissa sisään voi kirjautua:

$ docker run -it konteinerin_nimi

Käynnistyshetkessä konteinerille voi antaa tietty nimi:

$ docker run -it --name konteinerin_nimi imagen_nimi

DockerHub toiminta

Docker Hub on image varasto https://hub.docker.com/

Se on GitHub tyyppinen varasto, jossa on julkiset imaget ja maksullisena palveluna tarjotaan vielä private repository mihin muilla ei ole pääsyoikeutta. Kun luo sinne käyttäjätilin voi talleta omaa image varastoon.

Docker Host on kone missä docker on asennettu ja minkä käyttöjärjestelmän päälle rakennetaan konteinerit olemassa olevista imageista. Jos tuli komento rakentaa konteinerin imagesta mitä ei löydy paikallisesta varastosta, niin docker host lataa image docker hub:ista.

Docker Client on ohjelma millä annetaan komentoja Dockerille käynnistää, ladata, rakentaa konteineri, jne. Linux käyttöjärjestelmässä docker client toimii terminaalissa, mutta on olemassa docker klientit graafisella käyttöliittymällä esimerkiksi Kitematic https://kitematic.com/

Lisäksi on olemassa API mikä antaa mahdollisuuden käyttää konteinerit REST kautta sovelluksista.

DOCKER WORKFLOW

Imaget eroavat toisistaan. Olemassa on viralliset (official) ja yksityishenkilöiden luomat imaget. Viralliset imaget kirjoitetaan ilman slash merkkiä. Kaikki yksityiset imaget alkavat käyttäjän nimellä esimerkiksi minun image xelsinki/docker. Kun kirjoitetaan haku kenttään aihe, niin luettelon ensimmäisenä tulee virallinen image ja sitten käyttäjien julkiset imaget. Komennolla $docker search voidaan etsiä konteinerit DockerHub:ista.

Imaget eroavat toisistaan vielä toisella tavalla. On olemassa Base Imaget millä ei ole parent(isäntä) imagea. Ne ovat yleensä käyttöjärjestelmäpohjaisia kuten ubuntu, busybox, debian, alpine.

Toiset ovat Child imaget, mitkä perustuvat alkuperäisellä imagella ja alkavat:
From source-image

Esimerkiksi: From maven:alpine

tämä maven image perustuu suositun Alpine Linux Project imageen, joka on vain 5 megatavua kokoinen ja sen takia hyvin suosittu web-sovellusten julkaisu- ja testialustana.

Dockerfile

Docker konteinerin asetuksia voidaan määrittää joko käynnistysrivissä antamalla pitkän ja sekavan komennon tai kirjoittamalla ensin Dockerfile nimisen tiedoston jossa yksinkertaisella syntaksilla määrittään konteinerin ympäristön, muuttujia ja kokonpanon.

Esimerkiksi:
#Build from the Java 8 maven image (include JDK 8 and Maven) FROM maven:3.3-jdk-8 EXPOSE 8080 ADD dockerbuild/settings.xml /root/.m2/settings.xml RUN mkdir -p /usr/src/app WORKDIR /usr/src/app ADD . /usr/src/app RUN mvn install CMD ["java","-jar","target/my-jar-file.jar"]

Tässä oli esimerkki Dockerfile tiedostosta, joka on konfiguraatio tekstitiedosto. Siinä on komentoja Docker Clientille, miten pitää luoda konteineri. Sen komentoja ovat hyvin lähellä Linux Bash syntaksia.

From maven:3.3-jdk-8

kertoo mistä imagesta luodaan konteinerin

EXPOSE 8080

kertoo mitkä portit pitää avata

ADD dockerbuild/settings.xml /root/.m2/settings.xml

tämä rivi lisää settings.xml tiedosto konteinerin /root/.m2/settings.xml kansioon, jossa maivenin kirjastot sijaitsevat.

RUN mkdir -p /usr/src/app

tämä rivi luo kansion konteineriin

WORKDIR /usr/src/app

tämä rivi asettaa sen kansion työkansioksi, eli toimintaa siirtyy tähän kansioon
ADD . /usr/src/app

tämä kopioi tiedostot host koneen kansiosta konteinerin työkansioon

RUN mvn install

tämä rakentaa maven projektin

CMD ["java","-jar","target/my-jar-file.jar"]

CMD komento kertoo mitkä komennot pitää suorittaa konteinerin käynnistyessä. (Tässä on hyvä mainita se että CMD suoritetaan vain konteinerin käynnistyessä.)

CMD on kaksi syntaksia. Toinen on Shell format ja toinen on Exec format:

Esimerkiksi:

Shell format:

CMD ping 127.0.0.1 -c 30

Exec format:

CMD [“ping”, “127.0.0.1”, “-c”, “30”]

(lainausmerkit pitää olla oikeat)

Melkein samaa pystyy tekemään komennolla ENTRYPOINT, eli käynnistyskomennot.

ENV (environment) käytetään, kun halutaan mainita ympäristön muuttujat tai esimerkiksi:

ENV MAX_RAM 512m – maksimi keskusmuistin koko

ENV DOMAIN_NAME joku_domain - domainin nimi

————————————-

Näin voidaan tehdä rungon ja sitten vaihtaa vain joku muuttujista, esim. version numeroa:

ENV ARCHIVE apache-tomcat-8.0.33 ENV INSTALL_DIR ENV SERVER_HOME ${INSTALL_DIR}/${ARCHIVE}

————————————-

VOLUME rivillä pystyy jakamaan resurssit ja kansiot isäntäkoneesta konteineriin

Mountaus onnistuu myös dockerin käynnistyessä

$ docker run -d -P -v /myvolume nginx:1.7

Seuraava jakaa /data/src kansion isäntäkoneesta /test/src kansioon myös konteinerille.

$ docker run -i -t -v /data/src:/test/src nginx:1.7

Verkkomääritykset tehdään käynnistäessä, näin sillattaan portit konteinerin ja isäntäkoneen välillä

$ docker run -d -p 8080:80 nginx:1.7

Iso -P kirjain automattisesti kytkee samat portit konteinerista isäntäkoneeseen.

$ docker run -d -P nginx:1.7

Käynnistettyyn konteinerin sisään pystyy kirjautumaan näin:

$ docker exec -i -t containerin_nimi sh

Linux pohjaisen konteineriin bash voi käynnistää näin:

$ docker exec -it containerin_nimi bash

$ docker exec -komennolla pystyy antamaan käskyjä jo käynnissä olevalle konteinerille.

Dockerfile komennot on hyvää kirjoittaa mahdollisemmin monella argumentilla (multi-line arguments), koska jokainen uusi komento luo uuden väliaikaisen konteinerin ja se vie aikaa ja resursseja. Jos pitää asentaa konteineriin monta sovellusta, niin parempi tehdä näin.
…

RUN apt-get update && apt-get install -y \ bzr \ cvs \ git \

…

.dockerignore

Ennen kun Docker CLI lähettää tiedot Docker daemonille se etsii projektin root kansiosta .dockerignore tiedoston, jossa mainitaan mitä halutaan olla kopiomatta konteineriin ADD ja COPY komennoilla. Se antaa mahdollisuuden olla lähettämättä liian ison tai salaista tietoa sisältävän datan konteineriin.

. dockerignore syntaksi:

#comment

*/tiedoston_nimi – tiedoston tai kansion nimi alikansiossa

*/*/tiedoston_nimi – tiedoston tai kansion nimi toisessa alikansiossa esim /dir/dir/tiedosto

tiedoston_nimen_alku* – jonka tiedoston tai kansion nimi alkaa ..

!poikkeus – Poikkeus poikkeuksesta.

tiedoston_nimi? – tiedosto tai kansio nimellä jonka jälkeen on joku merkki esim. tiedoston_nimi1

https://docs.docker.com/engine/reference/builder/#dockerignore-file

Maven projekti konteineriin

Kokeilen rakentaa image suoraan maven projektista. Projektin CLASSPATH kansioon teen Dockerfile tiedoston. Sitten pitää rakentaa imagen komennolla:

$ docker build -t xelsinki/my_maven .

xelsinki on minun käyttäjänimi docker hubilla ja my_maven on imagen nimi, lopussa pitää laittaa pisteen, se tarkoittaa, että Dockerfile haetaan tästä kansiosta.

Rakennan maven projekti:

:~/workspace/aleksandr$ mvn clean

[INFO] Scanning for projects…

[INFO]

[INFO] ————————————————————————

[INFO] Building aleksandr 1.0.0-BUILD-SNAPSHOT

[INFO] ————————————————————————

[INFO]

[INFO] — maven-clean-plugin:2.5:clean (default-clean) @ spring —

[INFO] Deleting /home/user/workspace/aleksandr/target

[INFO] ————————————————————————

[INFO] BUILD SUCCESS

[INFO] ————————————————————————

[INFO] Total time: 0.750 s

[INFO] Finished at: 2017-04-08T16:41:20+03:00

[INFO] Final Memory: 7M/143M

[INFO] ————————————————————————

user@hp:~/workspace/aleksandr$ $ mvn package

[INFO]

[INFO] — maven-war-plugin:2.2:war (default-war) @ spring —

[INFO] Packaging webapp

[INFO] Assembling webapp [spring] in [/home/user/workspace/aleksandr/target/spring-1.0.0-BUILD-SNAPSHOT]

[INFO] Processing war project

[INFO] Copying webapp resources [/home/user/workspace/aleksandr/src/main/webapp]

[INFO] Webapp assembled in [151 msecs]

[INFO] Building war: /home/user/workspace/aleksandr/target/spring-1.0.0-BUILD-SNAPSHOT.war

[INFO] WEB-INF/web.xml already added, skipping

[INFO] ————————————————————————

[INFO] BUILD SUCCESS

[INFO] ————————————————————————

[INFO] Total time: 21.165 s

[INFO] Finished at: 2017-04-08T16:43:53+03:00

[INFO] Final Memory: 20M/160M

[INFO] ————————————————————————

$ mvn docker:build $ docker run -p 8080:8080 -t aleksandr $ docker-machine ls

Asentamaani payara server on oikeasti GlassFish variaatio, niin localhost:8080 osoitteessa on sen aloitussivu ja localhost:8080/webapp osoitteessa löytyy sovellus itse.

Docker Windows koneella

Aloitin tutustua docker Linux Ubuntu käyttöjärjestelmällä, mutta käytän eniten Windows 8.1 Pro koneetta. Docker ohjeissa olin lukenut, että se toimii ainoastaan 64bit Windows 10 Pro, Enterprise and Education (Build 10586 or later), koska se käyttää järjestelmässä olevaa Hyper-V hypervisoria. Myöhemmin luvataan tehdä Docker myös muille Windows 10 versioille.

Minun Windows 8.1 Pro:ssa ei ole Hyper-V:ta, mutta Docker voi asentaa käyttämään VirtualBox hypervisoria. Pitää asentaa Docker Toolbox ja mukana tulee graafinen client Kitematic. Visuallisuus auttaa huomattavasti käyttämään olemassa olevat kontainerit.

Network

Docker konteinerit voi yhdistää yhteen verkkoon. Tähän on seuraavat komennot:

$ docker network create network_nimi $ docker network ls

näyttää kaikki verkot, host, brige, net (luomani verkko)

Lisätään käynnistetty konteineri verkkoon:

$docker network connect network konteinerin_nimi

Tarkistetaan verkko:

$docker network inspect network_nimi

Se näyttää verkon id, ip, gateway, jne.

Käynnistetään konteineri ja liitetään sen verkkoon:

$ docker run --net network_nimi -d --name containerin_nimi imagen_nimi

Poistetaan verkko:
$ docker network rm network_nimi

Muut docker network komennot: (selitys liittessä)

WAR-sovelluksen julkaisu Docker containerissa

Olen tehnyt pienen web sovelluksen joka alussa pyytää käyttäjänimen salasanan, ja pyytää valitsemaan onko käyttäjä admin. Sitten kun painetaan Login-näppäintä, siirrytään seuraavalle sivulle, jolla syötetyt tiedot tulostetaan ruudulle. Tiedot välitetään POST haulla, sovellus käyttää MVC mallia ja sovellus käynnistyy web-palvelimella.

Haluan laittaa tämän sovelluksen pyörimään konteinerissa. Sain sovelluksen war tiedostoon ja vein sen docker kansioon, jonne laitoin vielä kirjoittamani Dockerfile tiedoston. Sovellus tarvitsee web-palvelinta, niin konteinerin pohjana käytän virallisen Tomcat imagen.

Dockerfile

FROM tomcat MAINTAINER Aleksandr Pantsesnyi ADD web-mvc-sovellus.war /usr/local/tomcat/webapps/ EXPOSE 8080 CMD ["catalina.sh", "run"]

Kansiossa on koottu Maven Spring MVC sovellus WAR-tiedostossa ja yllä mainittu Dockerfile

Docker:ille annetaan seuraavat kommennot

$ docker build -t web . – rakenna image
$ docker run -it -p 8080:8080 web – käynnistää imagesta containerin, siltaa portit 8080:8080

Sen jälkeen sovellus on nähtävissä web-selaimessa.

Sovellukselle syötetyt tiedot välitetään Get-pyynnöllä seuraavalle näkymälle.

Koska en ole antanut mitään nimeä konteinerille, docker antoi itse nimen sleepy_wilson.

Docker rakentaa konteinerin vaiheittain, jokainen rivi Dockerfile :ssa on vaihe (step). Silloin se rakentaa väliaikaiset konteinerit (intermediate containers) mitkä poistetaan, kun saadaan rakennettua lopullisen konteinerin.

$ docker ps – komennolla pääsee näkemään käynnissä olevat konteinerit.

Moni-konteineriset ratkaisut käyttäen docker-compose.yml

Docker Compose on työkalu monikonteineristen Docker-sovellusten määrittämiseen ja käyttämiseen. Määritä sovelluksen palveluiden avulla Compose-komennolla. Sitten, yhdellä komennolla, luodaan ja aloitat kaikki palvelut kokoonpanosta. Saat lisätietoja kaikista Kompleksin ominaisuuksista nähdä ominaisuuksien luettelossa.

Yleensä halutaan konteinerin pyörittävän jonkun sovelluksen tai palvelun. Kun käynnistetään docker Dockerfile tiedostossa voi viittaa .sh scripti-tiedoston jossa voidaan määrittää kaikki käynnistävät ohjelmat.

Jos sovellus/ratkaisu on iso ja käyttää monta konteineria pitää käyttää Docker Compose. Docker Compose on työkalu monikonteineristen Docker-sovellusten määrittämiseen ja käyttämiseen. Sillä voi määrittää sovelluksen komponenttia – niiden konteinerit, kokoonpano, yhteydet ja säiliöt(volumes) – yhteen tiedostoon.

Compose käyttäminen on yleensä kolmivaiheinen prosessi. Ensimmäisessä vaiheessa määritellään ympäristö ja ympäristön muuttujia Dockerfile tiedoston avulla, jotta se voidaan käyttää missä tahansa paikassa. Toisessa vaiheessa määritetään sovelluksen muodostavat palvelut, jotta ne voidaan suorittaa yhdessä erillisessä ympäristössä. Silloin konfiguraatio tiedostona käytetään YAML tiedosto: docker-compose.yml tiedosto. Viimeisenä yhden komennon avulla asettaa kaiken ja aloita sovelluksen käytön. Compose käynnistetään: docker-compose up

Compose: https://github.com/docker/compose

Compose-file: https://docs.docker.com/compose/compose-file/

https://github.com/docker/docker.github.io/blob/master/compose/compose-file/index.md

* * Dockerfile (CMD, EXPOSE, VOLUME, ENV) konfiguraatiot jäävät voimaan ja niitä ei tarvitse mainita erikseen docker-compose.yml tiedostossa.

Esimerkki: docker-compose.yml (WordPress konteineri ja tietokanta konteineri ja volume db_data)

services:
db:
image: mysql:5.7
volumes:
– db_data:/var/lib/mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: somewordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress

wordpress:
depends_on:
– db
image: wordpress:latest
ports:
– “8000:80”
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: wordpress
volumes:
db_data:

Sitten käynnistetään sen:

$ docker-compose up -d

Sitten web-selaimessa avataan http://loclahost:8080 avautuu WordPress aloitusikkuna.

Docker versiot

Docker Community Edition on ilmainen, mutta Enterprise Edition on maksullinen. EE versiossa on ”business day support” mukana. Nyt on julkistettu beta-versio Docker kaupasta https://store.docker.com/ jossa docker imaget ja osa niistä on Docker-sertifioituja.

Bitnami moduulit ja Docker konteinerit

Olin tutustunut Bitnami XAMPP:iin kun olin tekemässä PHP-ohjelmointi kurssilla kotitehtävät. Koska olin tarvinnut PHP-palvelinta omaan koneeseen, asensin Bitnami XAMPP moduulin, jossa on Apache, MariaDB, PHP ja Perl. Käyttöohjeista sain selville, että Bitnami tarjoa open source ohjelmien moduulit, mitkä voi helposti asentaa pilviin tai konteineriin.

https://bitnami.com/containers

Bitnami jakaa konteinerit käyttötarkoitusryhmiin:

Development Containers (Ohjelmistokehityksen työkalut: Rails, SWIFT )

http://blog.bitnami.com/2016/06/introducing-bitnami-development.html

Custom Containers by Stacksmith ( Stacksmith ja GitHub yhdistelmä päivittämään konteinerit)
Turnkey applications & Infrastructure containers

Esimerkkiasennus: Ruby on Rails Bitnami moduulin asennus konteineriin

$ mkdir myrailsapp $ cd myrailsapp $ curl -L "https://raw.githubusercontent.com/bitnami/bitnami-docker-rails/master/docker-compose.yml" > docker-compose.yml $ docker-compose up

Syntaksit

Docker komennot

docker run – käynnistää konteinerin

docker run -it –name konteinerin_nimi imagen_nimi – käynnistää konteinerin tietyllä nimellä imagesta

docker stop konteinrin_nimi – pysäyttää konteinerin

docker start konteinrin_nimi – käynnistää pysäytetyn konteinerin

docker pause konteinrin_nimi – pysäyttää konteinerin

docker unpause konteinrin_nimi – käynnistää pysäytetyn konteinerin

docker ps – näyttää käynnistetyt konteinerit

docker ps -a – näyttää kaikki konteinerit myös pysäytetyt

docker rm konteinrin_nimi – poistaa konteinerin

docker rm $(docker ps -a -q -f status=exited) – poistaa kaikki lopettaneet toimintansa konteinerit

docker rmi imagen_nimi – poistaa imagen

docker images – näyttää kaikki lokaaliropositorilla olevat imaget

docker top konteinrin_nimi– näyttää prosessit konteinerissa

docker build – rakentaa konteinerin

docker commit konteinrin_nimi – luodaan uusi image konteinerista

docker search imagen_nimi – etsitään DockerHub repositorista imaget

docker pull imagen_nimi – lataa DockerHub repositorista image

docker push imagen_nimi – tallenna DockerHub repositorista imaget

docker version – näyttää client version ja server version

docker update options CONTAINER konteinrin_nimi – päivitetään konteinerin konfiguraatio

docker volume COMMAND – käsittelee volume. Command [create, inspect, ls, rm, prune]

docker exec -i -t konteinerin_nimi sh – Kirjaudutaan sisään konteineriin.

docker exec -it konteinerin_nimi bash – Kirjaudutaan sisään Linux pohjaisen konteineriin.

https://docs.docker.com/edge/engine/reference/commandline/docker/

Images

docker image – hallitsee imaget

docker images && docker image ls – näyttää kaikki imaget

docker image build – rakentaa imagen Dockerfile tiedostosta

docker image rm imagen_nimi –

docker image history imagen_nimi – näyttää imagen historia (koska on luotu, muutettu, jne..)

docker image import – importoi tiedot tarball pakkauksesta ja luo tästä imagen

docker image inspect imagen_nimi – näyttää täydet tiedot imagesta

docker image load OPTIONS – lataa image tar tiedostosta tai STDIN

docker image save imagen_nimi – tallenna image tar tiedostoon tai STDOUT

docker image prune – poistaa kaikki käyttömättömät imaget [–all, kaikki] [–force, vahvistamatta]

docker image pull imagen_nimi – lataa image repositorista (esim. DockerHub)

docker image push imagen_nimi – lähettää image repositoriin (esim. DockerHub)

docker image tag SOURCE TARGET – Luo TARGET_IMAGE, joka viittaa kohteeseen SOURCE_IMAGE

https://docs.docker.com/engine/reference/commandline/image/

Networking

docker network create verkon_nimi – Luodaan verkko

docker network connect konteinerin_nimi – Lisätään käynnistetty konteineri verkkoon

docker network ls – näyttää kaikki verkot

docker network rm verkon_nimi – poistaa verkon

docker network disconnect verkon_nimi konteinerin_nimi – kytke pois konteineri verkosta

docker network inspect verkon_nimi – näyttää tiedot verkosta

docker attach konteinerin_nimi – Lisätään käynnistetty konteineri verkkoon

https://docs.docker.com/engine/userguide/networking/work-with-networks/

Docker-machine

https://docs.docker.com/machine/reference/

Dockerfile

Environment variables are supported by the following list of instructions in the Dockerfile:

ADD
COPY
ENV
EXPOSE
LABEL
USER
WORKDIR
VOLUME
STOPSIGNAL

https://docs.docker.com/engine/reference/builder/#environment-replacement

Esimerkki muuttujien käytöstä:

FROM busybox


ENV foo /bar
WORKDIR ${foo}   # WORKDIR /bar
ADD . $foo       # ADD . /bar

COPY \$foo /quux # COPY $foo /quux

.dockerignore

. dockerignore syntaksi:

#comment

*/tiedoston_nimi – tiedoston tai kansion nimi alikansiossa

*/*/tiedoston_nimi – tiedoston tai kansion nimi toisessa alikansiossa esim /dir/dir/tiedosto

tiedoston_nimen_alku* – jonka tiedoston tai kansion nimi alkaa ..

!poikkeus – Poikkeus poikkeuksesta.

tiedoston_nimi? – tiedosto tai kansio nimellä jonka jälkeen on joku merkki esim. tiedoston_nimi1

https://docs.docker.com/engine/reference/builder/#dockerignore-file