https://github.com/ccnmtl/docker

utility dockerfiles
https://github.com/ccnmtl/docker

Last synced: about 2 months ago
JSON representation

utility dockerfiles

• Host: GitHub
• URL: https://github.com/ccnmtl/docker
• Owner: ccnmtl
• License: gpl-2.0
• Created: 2015-11-13T11:02:26.000Z (over 9 years ago)
• Default Branch: master
• Last Pushed: 2021-10-29T16:23:56.000Z (over 3 years ago)
• Last Synced: 2025-02-16T00:44:01.847Z (4 months ago)
• Language: Makefile
• Size: 91.8 KB
• Stars: 1
• Watchers: 5
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE
  • Code of conduct: CODE_OF_CONDUCT.md
  • Authors: AUTHORS.md

Awesome Lists containing this project

README

        
# docker

Utility dockerfiles for building and running our other

applications. These support a separated build + run workflow. Roughly

based on what Glyph describes

[here](https://glyph.twistedmatrix.com/2015/03/docker-deploy-double-dutch.html),

but modified to suit some of our existing conventions and needs.

## ccnmtl/django.base

General, all-purpose django base image. Based on Debian Bullseye. Both

the `django.build` and any run containers use it as a base.

## ccnmtl/django.build

Wheel building image. To use it, cd into a django project directory

that has a `requirements.txt` and something like the following:

    $ mkdir -p wheelhouse

    $ docker run --rm \

	    -v $(pwd):/app \

        -v $(pwd):/wheelhouse:/wheelhouse \

        ccnmtl/django.build

The result should be that you have a `wheelhouse` directory populated

with linux x64 wheels of every package specified in your

`requirements.txt`. This is suitable to then install into a run

container which has no development tools installed (other than

pip/virtualenv).

I also recommend just having a `Makefile` in your project with the

following contents:

    ROOT_DIR:=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))

    

    # use wheelhouse/requirements.txt as the sentinal so make

    # knows whether it needs to rebuild the wheel directory or not

    # has the added advantage that it can just pip install

    # from that later on as well

    wheelhouse/requirements.txt: requirements.txt

    	mkdir -p wheelhouse

    	docker run --rm \

    	-v $(ROOT_DIR):/app \

    	-v $(ROOT_DIR)/wheelhouse:/wheelhouse \

    	ccnmtl/django.build

    	cp requirements.txt wheelhouse/requirements.txt

    	touch wheelhouse/requirements.txt

    

    build: wheelhouse/requirements.txt

    	docker build -t ccnmtl/sample .

Then you can just do `make build` and it will be smart enough to not

re-run that step if your requirements haven't changed since the last

time it was run.

## ccnmtl/django.sample

Finally, you'll want to build the run image for your application from

a Dockerfile something like this sample one. It pulls in the

`wheelhouse` directory with all the wheels that the builder built and

installs them into a virtualenv (requiring no network access). Then it

brings in the rest of the application, runs the tests inside the

container, exposes ports, etc.

# todo:

* work out a similar approach to handle nodejs dependencies

* jshint + jscs included in build steps