From ed24e4107a7174d645177d418c3c67fbd0b67f7e Mon Sep 17 00:00:00 2001 From: Docker Library Bot Date: Thu, 8 Mar 2018 20:08:54 +0000 Subject: [PATCH] Run update.sh --- jruby/README.md | 21 +++++++++++++++------ pypy/README.md | 24 +++++++++++++++++++----- ruby/README.md | 22 +++++++++++++++------- 3 files changed, 49 insertions(+), 18 deletions(-) diff --git a/jruby/README.md b/jruby/README.md index 9b8ec3ad0..ce990dbf7 100644 --- a/jruby/README.md +++ b/jruby/README.md @@ -67,14 +67,23 @@ JRuby leverages the robustness and speed of the JVM while providing the same Rub ## Create a `Dockerfile` in your Ruby app project ```dockerfile -FROM jruby:1.7-onbuild +FROM jruby:9 + +# throw errors if Gemfile has been modified since Gemfile.lock +RUN bundle config --global frozen 1 + +WORKDIR /usr/src/app + +COPY Gemfile Gemfile.lock ./ +RUN bundle install + +COPY . . + CMD ["./your-daemon-or-script.rb"] ``` Put this file in the root of your app, next to the `Gemfile`. -This image includes multiple `ONBUILD` triggers which should be all you need to bootstrap most applications. The build will `COPY . /usr/src/app` and `RUN bundle install`. - You can then build and run the Ruby image: ```console @@ -84,10 +93,10 @@ $ docker run -it --name my-running-script my-ruby-app ### Generate a `Gemfile.lock` -The `onbuild` tag expects a `Gemfile.lock` in your app directory. This `docker run` will help you generate one. Run it in the root of your app, next to the `Gemfile`: +The above example `Dockerfile` expects a `Gemfile.lock` in your app directory. This `docker run` will help you generate one. Run it in the root of your app, next to the `Gemfile`: ```console -$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app jruby:1.7 bundle install --system +$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app jruby:9 bundle install --system ``` ## Run a single Ruby script @@ -95,7 +104,7 @@ $ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app jruby:1.7 bundle instal For many simple, single file projects, you may find it inconvenient to write a complete `Dockerfile`. In such cases, you can run a Ruby script by using the Ruby Docker image directly: ```console -$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp jruby:1.7 jruby your-daemon-or-script.rb +$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp jruby:9 jruby your-daemon-or-script.rb ``` # Image Variants diff --git a/pypy/README.md b/pypy/README.md index d3ce37327..56f98f2ba 100644 --- a/pypy/README.md +++ b/pypy/README.md @@ -64,19 +64,33 @@ PyPy started out as a Python interpreter written in the Python language itself. ## Create a `Dockerfile` in your Python app project ```dockerfile -FROM pypy:3-onbuild +FROM pypy:3 + +WORKDIR /usr/src/app + +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt + +COPY . . + CMD [ "pypy3", "./your-daemon-or-script.py" ] ``` -or (if you need to use PyPy 2): +or (if you need to use Python 2): ```dockerfile -FROM pypy:2-onbuild +FROM pypy:2 + +WORKDIR /usr/src/app + +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt + +COPY . . + CMD [ "pypy", "./your-daemon-or-script.py" ] ``` -These images include multiple `ONBUILD` triggers, which should be all you need to bootstrap most applications. The build will `COPY` a `requirements.txt` file,`RUN pip install` on said file, and then copy the current directory into`/usr/src/app`. - You can then build and run the Docker image: ```console diff --git a/ruby/README.md b/ruby/README.md index 7ae406754..c131f32ae 100644 --- a/ruby/README.md +++ b/ruby/README.md @@ -79,15 +79,23 @@ Ruby is a dynamic, reflective, object-oriented, general-purpose, open-source pro ## Create a `Dockerfile` in your Ruby app project ```dockerfile -FROM ruby:2.1-onbuild +FROM ruby:2.5 + +# throw errors if Gemfile has been modified since Gemfile.lock +RUN bundle config --global frozen 1 + +WORKDIR /usr/src/app + +COPY Gemfile Gemfile.lock ./ +RUN bundle install + +COPY . . + CMD ["./your-daemon-or-script.rb"] ``` Put this file in the root of your app, next to the `Gemfile`. -This image includes multiple `ONBUILD` triggers which should be all you need to bootstrap most applications. The build will `COPY . /usr/src/app` and `RUN -bundle install`. - You can then build and run the Ruby image: ```console @@ -97,10 +105,10 @@ $ docker run -it --name my-running-script my-ruby-app ### Generate a `Gemfile.lock` -The `onbuild` tag expects a `Gemfile.lock` in your app directory. This `docker run` will help you generate one. Run it in the root of your app, next to the `Gemfile`: +The above example `Dockerfile` expects a `Gemfile.lock` in your app directory. This `docker run` will help you generate one. Run it in the root of your app, next to the `Gemfile`: ```console -$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app ruby:2.1 bundle install +$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app ruby:2.5 bundle install ``` ## Run a single Ruby script @@ -108,7 +116,7 @@ $ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app ruby:2.1 bundle install For many simple, single file projects, you may find it inconvenient to write a complete `Dockerfile`. In such cases, you can run a Ruby script by using the Ruby Docker image directly: ```console -$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp ruby:2.1 ruby your-daemon-or-script.rb +$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp ruby:2.5 ruby your-daemon-or-script.rb ``` ## Encoding