docker-library
/
docs
mirror of https://github.com/docker-library/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1169 from infosiftr/onbuild 

Remove a few more onbuild references
This commit is contained in:
yosifkit 2018-03-08 11:47:06 -08:00 committed by GitHub
parent d5f7039b41 9d5f465339
commit 622912aa49
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 49 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
jruby/content.md
View File

@ -15,14 +15,23 @@ JRuby leverages the robustness and speed of the JVM while providing the same Rub
## Create a `Dockerfile` in your Ruby app project ## Create a `Dockerfile` in your Ruby app project
```dockerfile ```dockerfile
FROM %%IMAGE%%:1.7-onbuild FROM %%IMAGE%%: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"] CMD ["./your-daemon-or-script.rb"]
``` ```
Put this file in the root of your app, next to the `Gemfile`. 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: You can then build and run the Ruby image:
```console ```console
@ -32,10 +41,10 @@ $ docker run -it --name my-running-script my-ruby-app
### Generate a `Gemfile.lock` ### 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 ```console
$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:1.7 bundle install --system $ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:9 bundle install --system
``` ```
## Run a single Ruby script ## Run a single Ruby script
@ -43,5 +52,5 @@ $ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:1.7 bundle in
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: 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 ```console
$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%: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 %%IMAGE%%:9 jruby your-daemon-or-script.rb
``` ```

24
pypy/content.md
View File

@ -13,19 +13,33 @@ PyPy started out as a Python interpreter written in the Python language itself.
## Create a `Dockerfile` in your Python app project ## Create a `Dockerfile` in your Python app project
```dockerfile ```dockerfile
FROM %%IMAGE%%:3-onbuild FROM %%IMAGE%%: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" ] CMD [ "pypy3", "./your-daemon-or-script.py" ]
``` ```
or (if you need to use PyPy 2): or (if you need to use Python 2):
```dockerfile ```dockerfile
FROM %%IMAGE%%:2-onbuild FROM %%IMAGE%%: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" ] 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: You can then build and run the Docker image:
```console ```console

22
ruby/content.md
View File

@ -11,15 +11,23 @@ Ruby is a dynamic, reflective, object-oriented, general-purpose, open-source pro
## Create a `Dockerfile` in your Ruby app project ## Create a `Dockerfile` in your Ruby app project
```dockerfile ```dockerfile
FROM %%IMAGE%%:2.1-onbuild FROM %%IMAGE%%: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"] CMD ["./your-daemon-or-script.rb"]
``` ```
Put this file in the root of your app, next to the `Gemfile`. 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: You can then build and run the Ruby image:
```console ```console
@ -29,10 +37,10 @@ $ docker run -it --name my-running-script my-ruby-app
### Generate a `Gemfile.lock` ### 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 ```console
$ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:2.1 bundle install $ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:2.5 bundle install
``` ```
## Run a single Ruby script ## Run a single Ruby script
@ -40,7 +48,7 @@ $ docker run --rm -v "$PWD":/usr/src/app -w /usr/src/app %%IMAGE%%:2.1 bundle in
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: 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 ```console
$ docker run -it --rm --name my-running-script -v "$PWD":/usr/src/myapp -w /usr/src/myapp %%IMAGE%%: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 %%IMAGE%%:2.5 ruby your-daemon-or-script.rb
``` ```
## Encoding ## Encoding