Skip to content

alpine-pydio

Deprecation Warning

This image has been deprecated and no updates (or support) may be available in future. Even though it is a container, it may or may not keep working as expected, use at your own risk.

updated stars forks watchers issues issues-pr
pulls stars x86_64

Container for Alpine Linux + S6 + NGINX + PHP7 + Pydio

This image containerizes Pydio Community edition, providing a FOSS solution to sync & share files among members and collaboration.

Based on Alpine Linux from the php image with NGINX, PHP7 and the pydio scripts overlayed on it. Versioned accordingly with releases from /pydio/pydio-core.

Get the Image

Pull the image from Docker Hub.

docker pull woahbase/alpine-pydio
Image Tags

The image is tagged respectively for the following architectures,

   x86_64

latest tag is retagged from x86_64, so pulling without any tag fetches you that image. For any other architectures specify the tag for that architecture. e.g. for armv8 or aarch64 host it is alpine-pydio:aarch64.

Run

Running the container starts the service.

docker run --rm -it \
  --name docker_pydio \
  -p 80:80 \
  -p 443:443 \
  -v $PWD/config:/config \
  -v $PWD/data:/data \
woahbase/alpine-pydio:x86_64
Multi-Arch Support

If you want to run images for other architectures on a x86_64 machine, you will need to have binfmt support configured for your machine before running the image. multiarch, has made it easy for us containing that into a docker container, just run

docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

Now images built for other architectures will also be executable. This is optional though, without the above, you can still run the image that is made for your architecture.

Configuration

  • Pydio is located at the endpoint /pydio/, with configurations at /config/pydio/ and data at /data.

  • Pydio source is located at /opt/pydio/pydio.zip.

  • These configurations are inherited from the nginx image:

    • Drop privileges to alpine whenever configured to. Respects PUID / PGID.

    • Binds to both http(80) and https(443). Publish whichever you need, or both.

    • Default configs setup a static site at / by copying /defaults/index.html at the webroot location /config/www/. Mount the /config/ locally to persist modifications (or your webapps). NGINX configs are at /config/nginx, and vhosts at /config/nginx/site-confs/.

    • 4096bit Self-signed SSL certificate is generated in first run at /config/keys. Pass the runtime variable SSLSUBJECT with a valid info string to make your own.

    • .htpasswd is generated with default credentials admin/insecurebydefault at /config/keys/.htpasswd

    • Sets up a https and auth protected web location at /secure.

    • If you're proxying multiple containers at the same host, or reverse proxying multiple hosts at the same container, you may need to add --net=host and/or add entries in your firewall to allow traffic.

Stop the container with a timeout, (defaults to 2 seconds)

docker stop -t 2 docker_pydio

Restart the container with

docker restart docker_pydio

Removes the container, (always better to stop it first and -f only when needed most)

docker rm -f docker_pydio
Shell access

Get a shell inside a already running container,

docker exec -it docker_pydio /bin/bash

Optionally, login as a non-root user, (default is alpine)

docker exec -u alpine -it docker_pydio /bin/bash

Or set user/group id e.g 1000/100,

docker exec -u 1000:100 -it docker_pydio /bin/bash
Logs

To check logs of a running container in real time

docker logs -f docker_pydio

Build Your Own

Feel free to clone (or fork) the repository and customize it for your own usage, build the image for yourself on your own systems, and optionally, push it to your own public (or private) repository.

Here's how...

Setting up

Before we clone the /repository, we must have Git, GNU make, and Docker (optionally, with buildx plugin for multi-platform images) setup on the machine. Also, for multi-platform annotations, we might require enabling experimental features of Docker.

Now, to get the code,

Clone the repository with,

git clone https://github.com/woahbase/alpine-pydio
cd alpine-pydio
Always Check Before You Make!

Did you know, we could check what any make target is going to execute before we actually run them, with

make -n <targetname> <optional args>

Build and Test

To create the image for your architecture, run the build and test target with

make build test

For building an image that targets another architecture, it is required to specify the ARCH parameter when building. e.g.

make build test ARCH=x86_64

Make to Run

Running the image creates a container and either starts a service (for service images) or provides a shell (can be either a root-shell or usershell) to execute commands in, depending on the image. We can run the image with

make run

But if we just need a root-shell in the container without any fance pre-tasks (e.g. for debug or to test something bespoke), we can run bash in the container with --entrypoint /bin/bash. This is wrapped in the makefile as

make shell
Nothing vs All vs Run vs Shell

By default, if make is run without any arguments, it calls the target all. In our case this is usually mapped to the target run (which in turn may be mapped to shell).

There may be more such targets defined as per the usage of the image. Check the makefile for more information.

Push the Image

If the build and test steps finish without any error, and we want to use the image on other machines, it is the next step push the image we built to a container image repository (like /hub), for that, run the push target with

make push

If the built image targets another architecture then it is required to specify the ARCH parameter when pushing. e.g.

make push ARCH=x86_64

That's all folks! Happy containerizing!

Maintenance

Sources at Github. Images at Docker Hub.

Maintained (or sometimes a lack thereof?) by WOAHBase.