Introductie
Continuous Integration (CI) en Continuous Deployment (CD) zijn momenteel enkele van de meest trending onderwerpen in softwareontwikkeling. Om het CI/CD aspect van softwarearchitectuur te bereiken, maken ontwikkelaars gebruik van containers. Containers zijn lichtgewicht, gevirtualiseerde, draagbare, software-gedefinieerde omgevingen. In containers kan de software geïsoleerd draaien van andere software die op de fysieke hostmachine draait. De focus van deze handleiding ligt op het gebruik van het containerplatform Docker om webapplicaties te implementeren en uit te voeren. Docker helpt om het installatieproces van een webserverstack te stroomlijnen. In deze handleiding gebruiken we de LEMP-stack om een Laravel-applicatie te serveren.
De LEMP-stack combineert Linux als besturingssysteem, Nginx als webserver, MySQL als database, en PHP als taal voor scripting en dynamische verwerking. Je kunt onze handleiding over het installeren en configureren van een LEMP-stack op Ubuntu volgen. Laravel is een van de beste PHP-frameworks voor het ontwikkelen van webapplicaties.
Docker biedt een tool genaamd Docker Compose voor het definiëren van het installatieproces van een docker-container. Docker Compose stelt ontwikkelaars in staat om de infrastructuur van hun applicatie, services, volumes, netwerken en eventuele afhankelijkheden te definiëren in één bestand genaamd het docker-compose-bestand. Het kan meerdere Docker-containers beheren via commando's zoals docker container create, docker container run, enz.
In deze handleiding leer je hoe je een Laravel-webapplicatie met Nginx en MySQL implementeert in een Docker-container. De configuraties voor de volledige stack worden gedefinieerd in een docker-compose-bestand, evenals andere configuratiebestanden voor PHP, MySQL en Nginx. Laten we beginnen!
Eerst en vooral
- Aangezien dit een praktische handleiding is, moet je een installatie hebben van Ubuntu 20.04 als je initiële besturingsomgeving. Je moet ook een niet-rootgebruiker met sudo-privileges hebben. Hier is een stapsgewijze handleiding om je te helpen je Ubuntu-server in te richten.
- Je moet Docker installeren. We hebben een handleiding over hoe je Docker installeert en bedient op Ubuntu 18.04.
- Je moet Docker Compose installeren volgens de handleiding uit de officiële Docker-documentatie.
Stap 1: Download Laravel en installeer de afhankelijkheden
De eerste stap is om de Laravel-code uit een repository te halen. In werkelijke scenario's heb je je Laravel-code mogelijk ergens in een repository staan, bijvoorbeeld op GitHub, Bitbucket, GitLab, enz. Voor deze handleiding klonen we echter de nieuwste versie van de officiële Laravel-repository op GitHub. De repository bevat een composer-bestand, een afhankelijkheidsbeheerder op applicatieniveau voor PHP. Omdat we willen dat alles binnen de Docker-container draait, installeren we de afhankelijkheden met behulp van de Docker composer-image. Dit helpt ons ook te voorkomen dat we composer wereldwijd op de daadwerkelijke hostmachine moeten installeren. Start vervolgens je terminal op.
Ga naar je thuismap:
|
1 |
cd ~ |
Voer het volgende commando uit om de repository te klonen naar een map genaamd laravel-web. Je bent vrij om deze te noemen zoals je wilt. Op het moment van schrijven haalt dit commando Laravel versie 8 op. Wanneer je het commando uitvoert, zul je waarschijnlijk een nieuwere versie vinden:
|
1 |
git clone https://github.com/laravel/laravel.git laravel-web |
Ga vervolgens naar de map waarin je zojuist de repository hebt gekloond:
|
1 |
cd ~/laravel-web |
Voer het volgende commando uit om de mappen te koppelen die nodig zijn voor je Laravel-app met behulp van Dockers composer-image:
|
1 |
docker run --rm -v $(pwd):/app composer install |
De vlaggen -v en –rm in het docker run-commando maken een tijdelijke container aan die aan de huidige map wordt gekoppeld (bind-mount) voordat deze wordt verwijderd. Het commando kopieert de inhoud van ~/laravel-web naar de container en zorgt ervoor dat de door composer gemaakte vendor-map wordt teruggekopieerd naar de huidige map.
Nu moet u het eigendom van de laravel-web-directory wijzigen naar de niet-rootgebruiker. Dit maakt het mogelijk om met uw applicatiecode te werken als een niet-rootgebruiker en processen binnen de container uit te voeren in de volgende stappen. Voer de volgende opdracht uit om het eigendom te wijzigen:
|
1 |
sudo chown -R $USER:$USER ~/laravel-web |
Uw applicatiecode staat nu op zijn plaats. De directory is eigendom van een niet-rootgebruiker, dus u kunt doorgaan met het definiëren van de applicatiediensten in het docker-composer-bestand.
Stap 2: Het Docker Compose-bestand maken
Docker Compose vereenvoudigt het proces van het bouwen en implementeren van een applicatie. Zodra u de configuraties en diensten hebt gedefinieerd, kunt u uw applicatie eenvoudig implementeren op elke hostmachine waarop Docker en Docker Compose zijn geïnstalleerd, zonder dat u zich zorgen hoeft te maken over de applicatie-afhankelijkheden. Het belangrijkste is dat u dit kunt doen met slechts één Docker Compose-opdracht, zoals we zullen zien in Stap 9.
In deze stap definieert u een Docker Compose-bestand met configuraties voor de webserver, database en applicatiediensten die nodig zijn om een Laravel-app te implementeren.
Docker Compose-bestanden zijn YAML-bestanden die zijn opgeslagen met de .yml-extensie. Houd er rekening mee dat een juiste inspringing noodzakelijk is voor een geldig Docker Compose-bestand. Voer de volgende opdracht uit om het bestand te maken en te openen met nano om het te bewerken:
|
1 |
nano ~/laravel-web/docker-compose.yml |
Vervolgens definieert u drie diensten in dit bestand: app, webserver en db. De db-sectie definieert de database-inloggegevens voor uw applicatie, dus zorg ervoor dat u een sterk mysql_root_password kiest en dit in die sectie vervangt. Kopieer en plak de volgende code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
version: '2.0' services: #PHP Service app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ networks: - app-network #Nginx Service webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" networks: - app-network #MySQL Service db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql networks: - app-network #Docker Networks networks: app-network: driver: bridge |
Hieronder volgen verklaringen van de definities van de diensten uit de bovenstaande code:
- app: Definieert de Laravel-applicatie en voert een aangepaste Docker-image uit, cloudsigma.com/php, die we zullen definiëren in Stap 4. Het stelt ook de working_dir in de container in op /var/www/html.
- webserver: Het haalt de nginx:alpine-image op van Docker en stelt de poorten 80 en 443.
- db: Het haalt de mysql:5.7.32-image op van Docker en definieert een paar omgevingsvariabelen. Deze omvatten een database genaamd laravel_web voor de applicatie en het root-wachtwoord voor de database. U kunt de database hernoemen naar een naam naar keuze. Vergeet niet om de MYSQL_ROOT_PASSWORD-eigenschap te vervangen door een sterk wachtwoord. Deze dienst koppelt ook poort 3306 op de host aan poort 3306 op de container.
De eigenschap container_name in elke service definieert een naam voor de container die overeenkomt met de service. Als u de eigenschap niet definieert, kiest Docker een willekeurige naam voor elke container.
De eigenschap networks definieert een bridge-netwerk genaamd app-network dat communicatie tussen containers vergemakkelijkt. Een bridge-netwerk wordt beheerd door een softwarebridge die alleen communicatie toestaat tussen containers op dezelfde netwerkbridge. De softwarecontroller van de bridge installeert stuurprogramma's die voorkomen dat containers op verschillende bridge-netwerken rechtstreeks met elkaar communiceren. Dit zorgt voor een hoog beveiligingsniveau, aangezien alleen gerelateerde services rechtstreeks kunnen communiceren. U kunt ervoor kiezen om meerdere services en netwerken te definiëren die verbinding maken met gerelateerde functies.
Stap 3: Gegevens persistent maken
Uw webapplicatie zal gegevens verwerken en aan uw gebruikers leveren. In deze stap begeleiden we u bij het definiëren van volumes en bind mounts voor uw servicedefinities om de gegevens van de applicatie persistent te maken. Docker biedt geweldige functies zoals bind mounts en volumes voor het persistent maken van gegevens en het opslaan van applicatieconfiguratiebestanden. We zullen deze gebruiken bij het opzetten van onze Laravel-app met Docker.
Volumes hebben om verschillende redenen de voorkeur, waaronder het bieden van back-ups en het persistent maken van gegevens buiten de levenscyclus van een container. Bind mounts verwijzen meestal naar een daadwerkelijke map op de hostmachine. Wanneer u een volume maakt, wordt er een nieuwe map gemaakt in de opslagmap van Docker, die door Docker wordt beheerd. Wanneer u een bind mount maakt, wordt een bestand of map op de hostmachine in een container gekoppeld (verwezen via het absolute pad). Dit is cruciaal voor onze webapplicatie, want wanneer u wijzigingen aanbrengt in de code op de hostmachine, zijn deze onmiddellijk beschikbaar voor de container.
Wees voorzichtig bij het gebruik van bind mounts. Processen die binnen de Docker-container worden uitgevoerd, kunnen wijzigingen aanbrengen in het bestandssysteem van de host en invloed hebben op niet-Docker-processen die op het hostsysteem worden uitgevoerd. Hoewel Docker-mounts een krachtige functie zijn, moet u zich bewust zijn van deze beveiligingsimplicaties.
Dat gezegd hebbende, laten we eens kijken hoe we deze twee functies in onze configuratie kunnen gebruiken. Eerst definiëren we een volume voor het persistent maken van de MySQL-database. Voeg in het Docker Compose-bestand dat we hebben gemaakt, onder de db-service, een volumes-eigenschap toe zoals hieronder gemarkeerd:
|
1 2 3 4 5 6 7 8 |
#MySQL Service db: ... volumes: - dbdata:/var/lib/mysql/ networks: - app-network ... |
Zoals gedefinieerd, zal het volume dbdata de inhoud van /var/lib/mysql persistent maken. Dit vergemakkelijkt back-ups en maakt het mogelijk om services opnieuw te starten zonder gegevens te verliezen. Vervolgens moet u de volumes-definitie aan het einde van het Docker Compose-bestand toevoegen om deze beschikbaar te maken voor alle services. Voer het volgende codefragment in onderaan het bestand:
|
1 2 3 4 |
#Volumes volumes: dbdata: driver: local |
Om verbinding te maken met een MySQL-database, moet u inloggegevens opgeven. Definieer hiervoor een bind mount door het volgende gemarkeerde codefragment toe te voegen aan de db-service onder de eigenschap volumes:
|
1 2 3 4 5 6 7 |
#MySQL Service db: ... volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf ... |
De code koppelt ~/laravel-web/mysql/my.cnf aan /etc/mysql/my.cnf in de container. Het gekoppelde bestand is het MySQL-configuratiebestand dat we zullen maken in Stap 7.
De container moet de Nginx-server gebruiken om uw applicatiecode te serveren. Daarom definiëren we voor dit doel twee bind mounts (één voor het Nginx-configuratiebestand en één voor de applicatiecode) onder de webserver-service. Voeg het volgende codefragment voor de volumes-definitie toe onder de webserver-service:
|
1 2 3 4 5 6 7 8 |
#Nginx Service webserver: ... volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network |
Deze regel – ./:/var/www/html koppelt de applicatiecode in de ~/laravel-web-directory aan de /var/www/html-directory in de container. Voor de tweede bind-mount wordt een configuratiebestand voor Nginx aangemaakt in ~/laravel-web/nginx/conf.d/. Dit wordt gekoppeld aan /etc/nginx/conf.d/ in de container. Hierdoor kun je het configuratiebestand op de hostmachine naar wens bijwerken. We zullen het Nginx-configuratiebestand aanmaken in Stap 6.
Om wijzigingen in de code automatisch in de container te laten reflecteren, koppelen we de applicatiecode via een bind-mount aan de container. Dit versnelt het implementatieproces. Voeg daarom het volgende gemarkeerde codefragment toe aan de app-service:
|
1 2 3 4 5 6 7 8 |
#PHP Service app: ... volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network |
De tweede regel koppelt een php-configuratiebestand, dat we zullen aanmaken in Stap 5 in het bestand ~/laravel-web/php/laravel.ini aan /usr/local/etc/php/conf.d/laravel.ini in de container.
Je complete Docker Compose-bestand zou er nu zo uit moeten zien:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
version: '2.0' services: #PHP Service app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network #Nginx Service webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network #MySQL Service db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf networks: - app-network #Docker Networks networks: app-network: driver: bridge #Volumes volumes: dbdata: driver: local |
Als alles er goed uitziet, druk dan op Ctrl + O om het bestand op te slaan. Druk vervolgens op Ctrl + X om de editor te sluiten. Op dit punt zou je in staat moeten zijn om een aangepaste Docker-image voor je applicatie te bouwen met het Docker Compose-bestand.
Stap 4: Maak de Dockerfile
Een Dockerfile bevat instructies die Docker kan gebruiken om aangepaste Docker-images te bouwen. Het kan ook de vereiste software installeren en de nodige instellingen voor je applicatie configureren. Ze specificeren de omgeving binnen een container die je applicatiecode zal hosten. Je kunt de gemaakte images pushen naar docker hub om ze te delen of ze op andere privé-registers te plaatsen.
We zullen een Dockerfile maken die de instructies specificeert om de Laravel-applicatie-image te bouwen. Gebruik nano om de Dockerfile aan te maken in de map ~/laravel-web:
|
1 |
nano ~/laravel-web/Dockerfile |
Voeg in de geopende editor de volgende code toe:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
FROM php:7.4-fpm # Kopieer composer.lock en composer.json naar de werkmap COPY composer.lock composer.json /var/www/html/ # Stel de werkmap in WORKDIR /var/www/html/ # Installeer afhankelijkheden voor de besturingssysteemsoftware RUN apt-get update && apt-get install -y \ build-essential \ libpng-dev \ libjpeg62-turbo-dev \ libfreetype6-dev \ locales \ zip \ jpegoptim optipng pngquant gifsicle \ vim \ libzip-dev \ unzip \ git \ libonig-dev \ curl # Wis cache RUN apt-get clean && rm -rf /var/lib/apt/lists/* # Installeer extensies voor php RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl RUN docker-php-ext-configure gd --with-freetype --with-jpeg RUN docker-php-ext-install gd # Installeer composer (php pakketbeheerder) RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer # Kopieer de inhoud van de bestaande applicatiemap naar de werkmap COPY . /var/www/html # Wijs machtigingen van de werkmap toe aan de www-data gebruiker RUN chown -R www-data:www-data \ /var/www/html/storage \ /var/www/html/bootstrap/cache # Stel poort 9000 bloot en start de php-fpm server (voor FastCGI Process Manager) EXPOSE 9000 CMD ["php-fpm"] |
De Dockerfile maakt eerst een image op basis van de php:7.4-fpm Docker-image. Dit is een op Debian gebaseerde image met PHP FastCGI-implementatie (PHP-FPM geïnstalleerd. Om Laravel correct te laten werken, zijn andere php-extensies zoals mcrypt, pdo_mysql, mbstring en imagick vereist, die door het script worden geïnstalleerd. Vervolgens installeert het de composer php-pakketbeheerder. De container zal deze gebruiken om de Laravel php-afhankelijkheden te installeren.
U kunt de RUN-richtlijn gebruiken om opdrachten te definiëren zoals installeren, bijwerken en instellingen configureren binnen de container. Het wijst ook gebruikersrechten toe. De WORKDIR-richtlijn specificeert de werkmap, in dit geval /var/www/html. Het script voert de CHOWN-opdracht uit om de machtigingen van de map /var/www/html toe te wijzen aan de www-data-gebruiker.
Voordat de image definitief wordt gebouwd, moet er een poort worden blootgesteld om toegang te verlenen tot de applicatie die in de container draait. De EXPOSE-opdracht stelt een poort, 9000, bloot voor de php-fpm-server. De laatste opdracht die wordt uitgevoerd is de CMD-richtlijn. Deze voert php-fpm uit om de server te starten.
U kunt nu op Ctrl + O drukken om het bestand op te slaan. Druk vervolgens op Ctrl + X om de editor te sluiten.
Stap 5: PHP configureren
In deze stap configureren we de php-service om inkomende verzoeken van Nginx te verwerken. Je maakt een laravel.ini-bestand aan in de php-map. Dit bestand zal de PHP-configuraties bevatten. Dit is het bestand dat je hebt gekoppeld (bind-mounted) aan /usr/local/etc/php/conf.d/laravel.ini in de container in Stap 3. De configuraties in dit bestand overschrijven het standaard php.ini-bestand dat normaal gesproken door PHP wordt gelezen wanneer het opstart. Voer de volgende opdracht uit om de php-map aan te maken:
|
1 |
mkdir ~/laravel-web/php |
Maak en open het laravel.ini-bestand in de php-map door de volgende opdracht in te voeren:
|
1 |
nano ~/laravel-web/php/laravel.ini |
Het standaard php.ini-bestand heeft een uploadlimiet die is ingesteld op 2M. Als voorbeeld laten we zien hoe je PHP-configuraties kunt aanpassen en instellen door de waarde van de toegestane uploadlimiet te wijzigen, voor het geval je grotere bestanden wilt uploaden. Voer de volgende regels code in het bestand in:
|
1 2 |
upload_max_filesize=80M post_max_size=80M |
Dit stelt de uploadlimiet in en je kunt bestanden uploaden met een totale grootte van maximaal 80MB. Je kunt andere php-configuraties toevoegen aan het laravel.ini-bestand om de standaard php-configuraties te overschrijven. Sla nu het bestand op en sluit het.
Stap 6: Nginx configureren
In deze stap configureren we Nginx om de php-service te gebruiken die we eerder hebben gedefinieerd. Het zal PHP-FPM gebruiken als de FastCGI-server om dynamische inhoud te serveren. Een FastCGI-server is software waarmee interactieve programma's kunnen communiceren met een webserver.
Zoals we hadden gedefinieerd in het docker-compose-bestand in Stap 3, maken we het Nginx-configuratiebestand app.conf aan in de map ~/laravel-web/nginx/conf.d/. Voer eerst de volgende opdracht uit om de map aan te maken:
|
1 |
mkdir -p ~/laravel-web/nginx/conf.d |
Maak en open vervolgens het app.conf-bestand met nano door de volgende opdracht in te voeren:
|
1 |
nano ~/laravel-web/nginx/conf.d/app.conf |
Voeg de volgende Nginx-configuratiecode toe aan het bestand:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
server { listen 80; index index.php index.html; error_log /var/log/nginx/error.log; access_log /var/log/nginx/access.log; root /var/www/html/public; location ~ \.php$ { try_files $uri =404; fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass app:9000; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param PATH_INFO $fastcgi_path_info; } location / { try_files $uri $uri/ /index.php?$query_string; gzip_static on; } } |
Nginx leest configuratiebestanden genaamd serverblokken om te weten welke map aan een websitebezoeker moet worden getoond op basis van de URL. Lees voor meer informatie over het instellen van serverblokken in onze handleiding over Nginx installeren op Ubuntu 18.04. De gedefinieerde richtlijnen dienen de volgende doelen:
- listen – Definieert de poort waarop de server luistert naar inkomende verzoeken, wat meestal poort 80 is.
- error_log & access_log – Definieert de bestanden voor het schrijven van applicatielogs.
- root – Definieert het webroot-pad, de map die elk verzoek aan de server vanaf het internet zal afhandelen.
In het location-blok voor php specificeert de fastcgi_pass-richtlijn dat de app-service luistert op een TCP-socket op poort 9000 (die was gedefinieerd in de Dockerfile). Dit instrueert de PHP-FPM-server om over het netwerk te luisteren en niet op een Unix-socket. Hoewel een Unix-socket een klein snelheidsvoordeel kan hebben ten opzichte van een TCP-socket, mist het een netwerkprotocol, waardoor de netwerkstack wordt overgeslagen.
Een Unix-socket zou geschikter zijn voor scenario's waarin hosts zich op één machine bevinden. Als u echter services hebt die op verschillende hosts draaien, heeft een TCP-socket het voordeel dat deze gedistribueerde services met elkaar kan verbinden. In ons geval draait de app-container op een andere host dan onze webservercontainer. Daarom is een TCP-socket het meest geschikt voor onze configuratie.
U kunt nu op Ctrl + O drukken om het bestand op te slaan en vervolgens op Ctrl + X om de editor te sluiten. De wijzigingen in de map nginx/conf.d/ worden automatisch doorgevoerd in de webservercontainer dankzij de bind-mount die u hebt toegevoegd in het Docker Compose-bestand in Stap 3.
Stap 7: MySQL configureren
Nadat we Nginx hebben geconfigureerd om met PHP te werken, kunnen we nu MySQL configureren om dynamische gegevens op te slaan en aan PHP te leveren. We hadden het Docker Compose-bestand al ingesteld om de benodigde extensies voor de communicatie tussen PHP en MySQL te installeren. We maken het MySQL-configuratiebestand my.cnf aan in de map mysql, die via een bind-mount wordt gekoppeld aan /etc/mysql/my.cnf, zoals we hadden gedefinieerd in de db-servicesectie van Docker Compose in Stap 3.
De MySQL-configuratie-instellingen en -wijzigingen kunnen op elk gewenst moment in het bestand my.cnf worden aangebracht. Ze moeten onmiddellijk in de container worden doorgevoerd. Maak eerst de map aan door de volgende opdracht in te voeren:
|
1 |
mkdir ~/laravel-web/mysql |
Maak vervolgens het bestand aan en open nano door de volgende opdracht in te voeren:
|
1 |
nano ~/laravel-web/mysql/my.cnf |
Voer het volgende codefragment in om het querylogboek in te schakelen en de locatie van het querylogbestand op te geven:
|
1 2 3 |
[mysqld] general_log = 1 general_log_file = /var/lib/mysql/general.log |
Door de eigenschap general_log als 1 te definiëren, staat u algemene logboeken toe. De eigenschap general_log_file specificeert de locatie van het logbestand. Druk op Ctrl + O om het bestand op te slaan en druk vervolgens op Ctrl + X om de editor te sluiten.
Stap 8: Laravel-omgevingsvariabelen instellen
Tot dit punt zijn alle services en configuratie-instellingen voltooid. We zouden dus onze containers kunnen implementeren. Er is echter een belangrijke stap die moet worden voltooid voordat onze webapplicatie daadwerkelijk bruikbaar is: omgevingsvariabelen. Het Laravel-framework verwacht een bestand genaamd .env dat het gebruikt om zijn omgeving te definiëren. Standaard wordt Laravel geleverd met het bestand .env.example dat u kunt kopiëren naar .env, waarna u de variabelen kunt aanpassen met uw werkelijke gegevens. Voer de volgende opdracht in om het bestand te kopiëren:
|
1 |
cp .env.example .env |
Zodra het is gekopieerd, opent u het bestand met nano om het te bewerken:
|
1 |
nano .env |
Hier is een screenshot van hoe het bestand eruit kan zien:
In het bestand is de volgende stap het aanpassen van de variabelen onder het DB_CONNECTION-blok, zoals u had ingesteld in de eerdere configuraties die we tot nu toe hebben gedaan. Werk dit als volgt bij:
- DB_HOST is de db databasecontainer.
- DB_DATABASE is de laravel_web.
- DB_USERNAME is de gebruikersnaam voor de database. Kies een naam naar keuze, maar voor deze handleiding gebruiken we laraveldocker.
- DB_PASSWORD is een sterk wachtwoord dat uw hierboven gemaakte gebruiker zal gebruiken om in te loggen op de database, dus kies een sterk wachtwoord. In Stap 10 zullen we deze gebruiker aanmaken met het wachtwoord dat u hier kiest.
Met de bijgewerkte waarden zou uw DB_CONNECTION er nu zo uit moeten zien:
Sla het bestand op en sluit het.
Stap 9: De Docker-containers uitvoeren
In dit stadium zijn al uw services en configuraties gedefinieerd in het Docker Compose-bestand. Er is slechts één opdracht nodig om alle containers te starten, de volumes te maken, de netwerken te verbinden en uw applicatie in te richten en te bouwen. Voer de volgende opdracht in uw terminal in:
|
1 |
docker-compose up -d |
Wanneer u de opdracht docker-compose up voor de eerste keer uitvoert, downloadt deze alle benodigde Docker-images. Als u de infrastructuur op uw lokale computer instelt, kan het even duren voordat dit is voltooid. Zodra de images zijn gedownload, maakt Compose de containers aan. De vlag -d geeft Docker de opdracht om de containers op de achtergrond uit te voeren. Als het proces met succes is voltooid, zou u zoiets als dit in uw terminal moeten zien:
Voer de volgende opdracht in uw terminal in om alle actieve containers op te sommen:
|
1 |
docker ps |
Het zou er ongeveer uit moeten zien als de onderstaande schermafbeelding, met details over de app-, webserver- en db-containers:
- CONTAINER ID – Een unieke identificatie voor elke container.
- NAMES – De servicenaam die aan elke container is gekoppeld, zoals gedefinieerd in het Docker Compose-bestand. (U kunt de container-id of de naam gebruiken om toegang te krijgen tot een container).
- IMAGE – De image-naam voor elke container.
- STATUS – Het toont informatie over de status van de container (deze kan gestopt zijn, actief zijn of opnieuw opstarten).
- PORTS – Het toont de poorten die een container openstelt.
Docker Compose biedt een opdracht genaamd exec die u kunt gebruiken om terminalopdrachten uit te voeren of toegang te krijgen tot de opdrachtregel in een container. We eerst willen we enkele opdrachten uitvoeren in de app-container, de container waarin de Laravel-app draait.
Docker biedt een opdracht om toegang te krijgen tot de opdrachtregel van een container. De syntaxis is als volgt: docker-compose exec container_name bash. Om toegang te krijgen tot de opdrachtregel van de app-container, voert u de volgende opdracht in:
|
1 |
docker-compose exec app bash |
Eenmaal op de opdrachtregel van de container kunt u enkele Laravel Artisan-configuratieopdrachten uitvoeren. Voer de volgende opdracht in om de laravel-sleutel te genereren en op te slaan in het .env-bestand:
|
1 |
php artisan key:generate |
Als de omgevingssleutel is ingesteld, kunt u de volgende opdracht uitvoeren om de configuratie-instellingen te cachen:
|
1 |
php artisan config:cache |
De configuraties worden opgeslagen in het bestand /var/www/html/bootstrap/cache/config.php in de container. U kunt op Ctrl + D drukken om de containerterminal te verlaten.
Om te bevestigen dat de Laravel-app is geïmplementeerd en actief is, bezoekt u uw server’s openbare IP-adres in uw browser (http://your_server_public_ip). U zou de welkomstpagina voor een nieuwe Laravel-installatie moeten zien:
Stap 10: Een MySQL-gebruiker configureren
In deze stap maken we een databasegebruiker aan voor de MySQL-database laravel_web die we in het docker-compose-bestand hebben gespecificeerd. Toen u de opdracht voor het bouwen van de container uitvoerde in Step 9, werd MySQL geïnstalleerd, maar werd er alleen een standaard root-beheerdersaccount aangemaakt, dat toevallig onbeperkte rechten op de database heeft. Om te voorkomen dat we de root-gebruiker gebruiken, maken we een speciale gebruiker aan, laraveldocker, om te gebruiken voor de applicatie. Dit is de gebruiker die u hebt opgegeven in de omgevingsvariabelen in Step 8. Krijg toegang tot de opdrachtregel in de terminal door de volgende opdracht in te voeren:
|
1 |
docker-compose exec db bash |
Eenmaal in de container logt u in op MySQL door de volgende opdracht in te voeren:
|
1 |
mysql -u root -p |
Voer bij de vraag om het wachtwoord het wachtwoord in dat u hebt ingesteld in de db-service in het docker-compose-bestand in Step 2.
Zodra u bent ingelogd op de MySQL-prompt, controleert u of u de database kunt zien die u in het docker-compose-bestand hebt opgegeven door de volgende SQL-opdracht in te voeren:
|
1 |
show databases; |
U zou de laravel_web-database moeten zien, of welke naam u ook hebt opgegeven voor uw configuratie:
Vervolgens maken we een gebruiker en wachtwoord aan voor de laravel_web-database. Dit moeten dezelfde gegevens zijn die u hebt opgegeven in het .env-bestand in Step 8. Voer de volgende opdracht uit om een gebruiker en wachtwoord aan te maken en alle rechten aan deze gebruiker te verlenen:
|
1 |
GRANT ALL ON laravel_web.* TO 'laraveldocker'@'%' IDENTIFIED BY 'your_strong_laravel_docker_password'; |
Voer de volgende opdracht in om de privileges te flushen, zodat de wijzigingen onmiddellijk van kracht worden:
|
1 |
FLUSH PRIVILEGES; |
Daarmee is de MySQL-gebruikersconfiguratie voltooid. Verlaat de MySQL-prompt door exit te typen en op enter te drukken. Verlaat ten slotte de db-container door op Ctrl + D te drukken.
Stap 11: Test de communicatie tussen de Laravel-applicatiecode en de MySQL-database
Tot deze stap is alles goed verlopen. We willen echter bevestigen dat de Laravel-code in de app-container kan communiceren met de MySQL-database in de db-container. Open eerst de terminal van de app-container door de volgende opdracht in te voeren:
|
1 |
docker-compose exec app bash |
De volgende stap is het uitvoeren van de Laravel-migratie-opdracht die de tabellen aanmaakt:
|
1 |
php artisan migrate |
Je zou het migratieproces in je terminal moeten zien terwijl Laravel de standaardtabellen aanmaakt:
Vervolgens testen we of we toegang hebben tot de database vanuit Laravel. Laravel wordt standaard geleverd met Tinker , waarmee je via de opdrachtregel met de hele applicatie kunt communiceren, inclusief toegang tot de database, het uitvoeren van taken, Eloquent ORM en meer. We kunnen Tinker gebruiken om de gegevens in de migrations-tabel te bekijken. Voer de volgende opdracht in om Tinker te openen:
|
1 |
php artisan tinker |
Zodra je in de Tinker-prompt bent, kun je de tabellen die door de migrate-opdracht zijn gemaakt, weergeven door het volgende in te voeren:
|
1 |
\DB::select('show tables'); |
De onderstaande schermafbeelding toont de uitvoer, dit zijn de tabellen die zich momenteel in de laravel_web-database bevinden:
Je kunt de gegevens in een tabel ophalen door de tabelnaam op te geven. Je kunt bijvoorbeeld de gegevens in de migrations-tabel ophalen door de volgende opdracht in te voeren:
|
1 |
\DB::table('migrations')->get(); |
De opdracht geeft de volgende uitvoer:
Uit de bovenstaande uitvoer blijkt dat je Laravel-applicatie goed is geconfigureerd en kan communiceren met de database. Je kunt experimenteren met meer opdrachten, zoals het maken van modellen, het uitvoeren van taken en meer. Je kunt de Tinker-prompt verlaten door op Ctrl + D te drukken.
Conclusie
In deze handleiding heb je een LEMP-stack Laravel-applicatie geïmplementeerd in een Docker-container. Je hebt de applicatie getest door de webinterface te openen en verbinding te maken met de database via Laravel Tinker. Je hebt de kracht van Docker Compose kunnen ervaren. Hiermee kun je een groep Docker-containers definiëren in één bestand, die vervolgens met slechts één opdracht kunnen worden uitgevoerd.
Als je verder vertrouwd wilt raken met containers, bekijk dan onze handleiding die laat zien hoe je Docker-bronnen opschoont – images, containers en volumes en ons gedetailleerde overzicht van de Kubernetes-tool.
Je kunt ook onze blog bezoeken voor meer informatie over Docker en Continuous Integration en Continuous Deployment.
Veel computerplezier!
Reacties
Nog geen reacties. Wees de eerste.