Docker images for both devpi-server and devpi-client, with both
Debian and Alpine versions available.
Devpi allows you to host a local PyPi cache, along with the ability for you to add your own packages that you do not want to upload publicly.
ℹ️ Docker tags use the same version numberings as the devpi packges on PyPi (server & client), but can be viewed on DockerHub as well: server & client.
This repository is split into two parts: the server and the client. You will of course need a working server before there is any point in using the client.
DEVPI_PASSWORD: The password to set for the "root" user on init (required).
The DEVPI_PASSWORD environment variable will set the root password on the
first startup of this image. Set it to something more secure than what I use
as an example here.
docker run -it -p 3141:3141 \
-e DEVPI_PASSWORD=password \
-v $(pwd)/data-server:/devpi/server \
--name devpi-server jonasal/devpi-server:latestThe command will also host mount the data directory from the server to your local folder, in order to persist data between restarts.
The first time this container is started a full re-index of the upstream PyPi will commence, so the logs might be spammed with "Committing 2500 new documents to search index." for a while.
It is possible to customize the devpi instance with any of the available arguments by appending them to the command displayed above:
docker run -it <...> jonasal/devpi-server:latest \
--threads 4 \
--debugDEVPI_URL: The URL to the devpi instance to connect to (default:http://localhost:3141/root/pypi)DEVPI_USER: The username to login to the devpi instance with (default:"")DEVPI_PASSWORD: The password for the user when logging in (default:"")
The DEVPI_URL environment variable is the only one that needs to be set, and
it will use the default unless you specify something else. The other two are
optional, and can be defined for convenience so you do not have to manually
login every time you start this container. Furthermore, if DEVPI_USER is set
but DEVPI_PASSWORD is empty you will be prompted for the password.
The following command expects that there is a functional devpi instance running on the local computer, and that the "root" user has a password set. The host mounted directory may be used to transfer files in and out of the container.
docker run -it --rm --network host \
-e DEVPI_USER=root \
-e DEVPI_PASSWORD=password \
-v $(pwd)/data-client:/devpi/client \
jonasal/devpi-client:latestImportant note here is that this container uses the "host" network, else the
localhost in the URL would just make so that the container tried to contact
itself and would thus not reach the container running the server program.
For a quick test to see if the devpi-server actually works you can make a
one-off installation like this:
pip install -i http://localhost:3141/root/pypi simplejsonThe server logs should move and the pip installation should be successful.
To then make this setting a bit more permanent you can edit ~/.pip/pip.conf
with this:
[global]
index-url = http://localhost:3141/root/pypiFollowing installations should then be going through your local cache.
By default devpi creates an index called root/pypi, which serves as a proxy
and cache for PyPI, and you can’t upload your own packages to it.
In order to upload local packages we need to create another index, and to make
our lives easier we will also configure it so that it "inherits" from the
root/pypi index. What this meas is that if our search for a package in the
local index fails it will fall back to the root/pypi index and try to find it
there. Thus we can add all our private packages without losing the ability to
find all the public ones.
To achieve this we will start the devpi-client container as root (we need
to be able to make modifications):
docker run -it --rm --network host \
-e DEVPI_USER=root \
-e DEVPI_PASSWORD=password \
-v $(pwd)/data-client:/devpi/client \
jonasal/devpi-client:latestInside the container we will first create another user:
devpi user -c local password=something_long_and_complicatedThen we will create an index under this new user that inherits from the
root/pypi index:
devpi index -c local/stable bases=root/pypi volatile=FalseRestart the container again, but this time specify the new index URL and the new user:
docker run -it --rm --network host \
-e DEVPI_URL="http://localhost:3141/local/stable" \
-e DEVPI_USER=local \
-e DEVPI_PASSWORD=something_long_and_complicated \
-v $(pwd)/data-client:/devpi/client \
jonasal/devpi-client:latestYou can now upload files from the /devpi/client folder to the current index
by running something similar to this:
devpi upload /devpi/client private_package-0.1.0-py3-none-any.whlAfter this you should be able to install it by pointing to the new index:
pip install -i http://localhost:3141/local/stable private_package
⚠️ This is semi-experimental since I am having trouble finding official documentation on the proper way to do this.
The best guide on upgrading devpi server I could find was this one, so I tried to integrate that into the entrypoint. It is not very automated, but you will at least have full control of what it is doing the entire time.
ℹ️ You should also only have to do this procedure when there is a change in the database schema. Such a change will warrant a major version bump, so this process is not necessary if you are just upgrading a minor or a patch version.
Begin by stopping any of the currently running devpi containers, and then run
the same image again with the /export folder mounted to initiate an export
process:
docker run -it --rm -e DEVPI_PASSWORD=password \
-v $(pwd)/data-server:/devpi/server \
-v $(pwd)/tmp:/export \
jonasal/devpi-server:old-tagIf this is successful you should now rename the old data folder (don't delete it before you know the new one works):
sudo mv data-server data-server.bakRun the new image with the /import folder mounted in order to initiate an
import process:
docker run -it --rm -e DEVPI_PASSWORD=password \
-v $(pwd)/data-server:/devpi/server \
-v $(pwd)/tmp:/import \
jonasal/devpi-server:new-tagWhen this one completes you can go back to running the image normally without
any of the import/export folders mounted. This should most likely give you a
functional upgraded instance of devpi. Cleanup of the extra folders can be done
with this simple command
sudo rm -r data-server.bak && sudo rm -r tmpI got most of the information I needed to complete this project from the following sources, perhaps they are useful for you too: