Most of the times I see in the docker-compose.yml two separated services for ngnix and php, like this:
version: '3.3'
services:
php:
image: php
ports:
- "127.0.0.1:8000:8000"
volumes:
- ".:/code_folder"
networks:
- default
ngnix:
image: ngnix
ports:
- "127.0.0.1:80:80"
volumes:
- ".:/code_folder"
networks:
- default
I would assume there must be a single image having ngnix and php together but it's not a commonly used approach.
Another question is:
how does it works, since those will be separated containers, both mounting the same code base?
You're missing mapping your Nginx configuration file which is what makes the whole difference.
The configuration file specifies that all requests for PHP files should be passed on to the PHP container. All non-PHP files are served directly by the Nginx container.
Because each container should run a single service. The design pattern should be it runs a service then when it completes it stops itself. It just happens that nginx and php need to continuously listen and therefor don't stop naturally
Related
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 10 months ago.
The community reviewed whether to reopen this question 10 months ago and left it closed:
Original close reason(s) were not resolved
Improve this question
I have running multiple containers separately which connected to each other using defined network in docker-compose.yml and my application is running perfect, so I want to create only one image for those multiple containers for deploying to my private repository (image with tags), I want to know what is the best practice to do that.
docker-compose.yml
version: '3.1'
networks:
lemp:
services:
nginx:
build:
context: .
dockerfile: Dockerfile
target: webserver
container_name: webserver
volumes:
- ./src/app:/var/www/html/app
ports:
- "80:80"
networks:
- lemp
php:
build:
context: .
dockerfile: Dockerfile
target: app
container_name: app
volumes:
- ./src/app:/var/www/html/app
ports:
- "9000:9000"
networks:
- lemp
Dockerfile
FROM nginx:1.21.6-alpine AS webserver
COPY ./src/ ./var/www/html
COPY ./nginx/conf.d/app.conf /etc/nginx/conf.d/app.conf
EXPOSE 80 443
FROM php:7.4-fpm-alpine AS app
EXPOSE 9000
You should plan to distribute your docker-compose.yml file, or perhaps a simplified version of it, as the standard way to run your combined application. If it requires two images, you'll need to push the two images separately to your repository; don't try to combine them. Do make sure the images are self-contained so you don't need the source code separately from the images to run them.
The docker-compose.yml file should roughly look like:
version: '3.8'
services:
nginx:
image: registry.example.com/nginx:${TAG:-latest}
ports:
- '80:80'
php:
image: registry.example.com/php:${TAG:-latest}
Calling out a couple of things here: I've removed the unnecessary networks: declarations (Compose provides a default network that works fine) and the unnecessary container_name: declarations. I've put in an image: line for each image in place of the build: block, and use an environment variable to inject the image tag. For the php container I've removed the ports: declaration since you probably don't want that externally accessible. Finally, for both containers I've removed the volumes: that override the image contents.
Next to this, put a docker-compose.override.yml file. This is not something you'd distribute. It can say:
version: '3.8'
services:
nginx:
build:
context: .
dockerfile: Dockerfile.nginx
php:
build:
context: .
dockerfile: Dockerfile.php
ports:
- '9000:9000'
If you have both files, Compose merges their settings. So for a developer this adds in the ports: to directly access the PHP-FPM service if required, and build: blocks to explain how to build both images. Since the combined Compose configuration has both build: and image:, docker-compose build will build images with the specified names tagged with your local registry name.
You should have a separate Dockerfile for each image you're building. The Nginx image resembles what you already have; for the PHP-FPM container you need to make sure you COPY the code into the image.
# Dockerfile.nginx
FROM nginx:1.21.6-alpine
COPY ./src/ /var/www/html/
COPY ./nginx/conf.d/app.conf /etc/nginx/conf.d/app.conf
# Dockerfile.php
FROM php:7.4-fpm-alpine
COPY ./src/app/ /var/www/html/app/
Now you can build and run the application locally. Double-check that it works correctly, without volumes: overwriting the image code.
docker-compose build
docker-compose up -d
curl http://localhost/
If this works, then you're set to distribute this. Pick a tag (a date stamp or the current source control ID are good choices), build the images, and push them to a Docker registry.
export TAG=20220418
docker-compose build
docker-compose push
Now you can copy only the docker-compose.yml file, but none of the other files we've touched, to the remote system, or put it in a GitHub repository, or something else. On that system, set $TAG to match, and run docker-compose up as usual. Docker will automatically pull the images from the repository. Since the images are self-contained, the only thing you need is the docker-compose.yml file.
scp docker-compose.yml there:
ssh root#there
export TAG=20220418
docker-compose up -d
Unclear what you really need. You can publish the individual containers to your registry and provide a downloadable Compose file for anyone to use those containers together, which will pull each image, separately.
Otherwise, you would need to copy all relevant steps from one Dockerfile to the other. Note: If you are running unique entrypoint/commands (processes) in each Dockerfile, then this is considered bad practice.
UPDATE
Looking at your example, you could install php-fpm into the Nginx container, copy the PHP files, and just serve the static content from there. However, I would recommend keeping separate containers, for sure. Nginx should be replaceable as a reverse proxy.
Also, you don't have a correct multi-stage Dockerfile (using FROM twice doesn't merge anything), and your Compose file is just running the same image (context) twice on two different ports.
I am pretty new with all of this docker stuff and I have this docker-compose.yml file:
fpm:
build:
context: "./php-fpm"
dockerfile: "my-fpm-dockerfile"
restart: "always"
ports:
- "9002:9000"
volumes:
- ./src:/var/www/src
depends_on:
- "db"
nginx:
build:
context: "./nginx"
dockerfile: "my-nginx-dockerfile"
restart: "always"
ports:
- "8084:80"
volumes:
- ./docker/logs/nginx/:/var/log/nginx:cached
- ./src:/var/www/src
depends_on:
- "fpm"
I am curious why do I need to add my project files in the fpm container as well as in the nginx?
Why isn't it enough to add it just only to my webserver? A web server is a place that holds the files and handles the request...
I believe that this information would be useful to other docker newbies as well.
Thanks in advance.
In your NGinx container you only need the statics and in your PHP-FPM container you only need the PHP files. If you are capable of splitting the files, you don't need any file in both sites.
Why isn't it enough to add it just only to my webserver? A web server
is a place that holds the files and handles the request...
NGinx handles requests from users. If a request is to a static file (configured in NGinx site), it sends the contents back to the user. If the request is to a PHP file (and NGinx is correctly configured to use FPM on that place), it sends the request to the FPM server (via socket or TCP request), which knows how to execute PHP files (NGinx doesn't know that). You can use PHP-FPM or whatever other interpreter you prefer, but this one works great when configured correctly.
If you just want an explanation why both need the access to the same files under
/var/www/src, I cannot provide a reliable answer since I’m not familiar neither with
nginx not fpm.
But I can provide an explanation what’s the purpose of doing it so.
First, to learn about docker, I highly recommend the official documentation, since it provides a great explanation: docs.docker.com
For learning the syntax of a docker-compose file, see docs.docker.com: Compose file reference
Your specific question
Let me break down what you have her:
You got two different images, fpm and nginx.
fpm:
...
nginx:
...
In principle, these containers (or services as they are called )
run completely independent from each other. This basically means, that they don't know that the other one exists.
Note: depends_on just expresses a dependency between services
Conclusion: Your webserver knows nothing about your second container.
As said: While I don't know the purpose of fpm, I assume that a common folder is the connection between these two containers. By using a common folder ./src on your host, they both have access to this ./src folder, thus can write to and read from it.
The syntax ./src:/var/www/src means, that this ./src folder is mapped (internally in your container) to :/var/www/src.
If a container writes to /var/www/src it will actually write to ./src on your host. This works vice versa.
Conclusion: They share a common directory where both containers can access the very same files.
Hope my explanation helps you understanting your docker-compose better.
Looking at a common docker-compose setup for a Nginx / combo like:
version: '3'
services:
nginx-example:
image: nginx:1.13-alpine
ports:
- "80:80"
volumes:
- ./www:/www
- ./config/site.conf:/etc/nginx/conf.d/default.conf
php-example:
image: php-fpm
volumes:
- ./www:/www
You find many examples like that to make sure, that if you change something in your local www folder it will be immediately picked up by a running container.
But when I do not want that and copy some php files/content etc. into the container:
Is it enough to create a volume of the same name for both containers and copy my files into that folder e.g. in Dockerfile?
Or is it even possible to not have a volume but create a directory in the container and copy the files there... and in that case: do I have to do for both nginx and php-fpm with the same files?
Perhaps my misunderstanding is around how the php-fpm container works in that combination (of course fastcgi... in conf points to the php-example:9000 standard)
My ideal solution would be to copy once and making sure that file permissions are handled.
How do I deliver the code of a containerized PHP application, whose image is based on busybox and contains only the code, between separate NGINX and PHP-FPM containers? I use the 3rd version of docker compose.
The Dockerfile of the image containing the code would be:
FROM busybox
#the app's code
RUN mkdir /app
VOLUME /app
#copy the app's code from the context into the image
COPY code /app
The docker-compose.yml file would be:
version: "3"
services:
#the application's code
#the volume is currently mounted from the host machine, but the code will be copied over into the image statically for production
app:
image: app
volumes:
- ../../code/cms/storage:/storage
networks:
- backend
#webserver
web:
image: web
depends_on:
- app
- php
networks:
- frontend
- backend
ports:
- '8080:80'
- '8081:443'
#php
php:
image: php:7-fpm
depends_on:
- app
networks:
- backend
networks:
cms-frontend:
driver: "bridge"
cms-backend:
driver: "bridge"
The solutions I thought of, neither appropriate:
1) Use the volume from the app's container in the PHP and NGINX containers, but compose v3 doesn't allow it (the volumes_from directive). Can't use it.
2) Place the code in a named volume and connect it to the containers. Going this way I can't containerize the code. Can't use. (I'll also have to manually create this volume on every node in a swarm?)
3) Copy the code twice directly into images based on NGINX and PHP-FPM. Bad idea, I'll have to maintain them to be in concert.
Got stuck with this. Any other options? I might have misunderstood something, only beginning with Docker.
I too have been looking around to solve a similar issue and it seems Nginx + PHP-FPM is one of those exceptions when it is better to have both services running in one container for production. In development you can bind mount the project folder to both nginx and php containers. As per Bret Fisher's guide for good defaults for php: php-docker-good-defaults
So far, the Nginx + PHP-FPM combo is the only scenario that I recommend using multi-service containers for. It's a rather unique problem that doesn't always fit well in the model of "one container, one service". You could use two separate containers, one with nginx and one with php:fpm but I've tried that in production, and there are lots of downsides. A copy of the PHP code has to be in each container, they have to communicate over TCP which is much slower than Linux sockets used in a single container, and since you usually have a 1-to-1 relationship between them, the argument of individual service control is rather moot.
You can read more about setting up multiple service containers on the docker page here (it's also listed in the link above): Docker Running Multiple Services in a Container
The way I see it, you have two options:
(1) Using Docker-compose : (this is for very simplistic development env)
You will have to build two separate container from nginx and php-fpm images. And then simply serve app folder from php-fpm on a web folder on nginx.
# The Application
app:
build:
context: ./
dockerfile: app.dev.dockerfile
working_dir: /var/www
volumes:
- ./:/var/www
expose:
- 9000
# The Web Server
web:
build:
context: ./
dockerfile: web.dev.dockerfile
working_dir: /var/www
volumes_from:
- app
links:
- app:app
ports:
- 80:80
- 443:443
(2) Use a single Dockerfile to build everything in it.
Start with some flavor of linux or php image
install nginx
Build your custom image
And serve multi services docker container using supervisord
I'm basically using the setup from: https://github.com/wouterds/docker (but not using mysql)
The following is my docker-compose.yml file:
nginx:
image: nginx:1.10.2
ports:
- 80:80
restart: always
volumes:
- ./nginx/conf:/etc/nginx/conf.d
- ~/server/firebase-test/code:/code
links:
- php
depends_on:
- php
php:
build: php
expose:
- 9000
restart: always
volumes:
- ./php/conf/php.ini:/usr/local/etc/php/conf.d/custom.ini
- ~/server/firebase-test/code:/code
It works correctly if I go to http://localhost
But I'm using this container setup to develop a bunch of different sites. Sometimes I need them running at the same time so they both try to use the localhost url which isn't possible. Is there a way for me to manually have them referenced by something like http://websitename.dev or http://[container-name].dev locally? Does docker-compose auto generated some kind of network mapping that I can use to access the container instead of http://localhost?
Pretty new to Docker so I'm a little lost and googling for the last hour didn't result in much other than a tool called "docker-hostmanager" but it doesn't work with the v2 syntax.
I believe you should be able to configure nginx to do this using the server_name directive:
server {
listen 80;
server_name example.org www.example.org;
...
}
http://nginx.org/en/docs/http/server_names.html