Bitnami/containers
2
0
Fork 0
mirror of https://github.com/bitnami/containers.git synced 2026-04-02 15:27:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #19 from sameersbn/stacksmith-merger

Browse Source 
Stacksmith merger
This commit is contained in:
Adnan Abdulhussein
2016-06-06 09:03:43 -07:00
parent 7a7b764e60 1e09102271
commit 254353931b
16 changed files with 178 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
bitnami/mongodb/.dockerignore Normal file
View File

@@ -0,0 +1,2 @@
.git/
tests/

1
bitnami/mongodb/.gitignore vendored
View File

@@ -1 +1,2 @@
*.run
*.tar.gz

23
bitnami/mongodb/Dockerfile
View File

@@ -1,20 +1,17 @@
FROM bitnami/base-ubuntu:14.04-onbuild
FROM gcr.io/stacksmith-images/ubuntu:14.04-r07
MAINTAINER Bitnami <containers@bitnami.com>
ENV BITNAMI_APP_NAME=mongodb \
BITNAMI_APP_USER=mongodb \
BITNAMI_APP_DAEMON=mongod \
BITNAMI_APP_VERSION=3.2.5-0
ENV BITNAMI_IMAGE_VERSION=3.2.6-r0 \
BITNAMI_APP_NAME=mongodb \
BITNAMI_APP_USER=mongo
ENV BITNAMI_APP_DIR=$BITNAMI_PREFIX/$BITNAMI_APP_NAME \
BITNAMI_APP_VOL_PREFIX=/bitnami/$BITNAMI_APP_NAME
ENV PATH=$BITNAMI_APP_DIR/bin:$BITNAMI_PREFIX/common/bin:$PATH
RUN $BITNAMI_PREFIX/install.sh --mongodb_password bitnami --disable-components common
RUN bitnami-pkg unpack mongodb-3.2.6-3 --checksum 9a019ffae6e3f69779512d39e95bb7256672999bb1eb96e3572550eb2bdd9738
ENV PATH=/opt/bitnami/$BITNAMI_APP_NAME/sbin:/opt/bitnami/$BITNAMI_APP_NAME/bin:$PATH
COPY rootfs/ /
ENTRYPOINT ["/app-entrypoint.sh"]
CMD ["harpoon", "start", "--foreground", "mongodb"]
VOLUME ["/bitnami/$BITNAMI_APP_NAME"]
EXPOSE 27017
VOLUME ["$BITNAMI_APP_VOL_PREFIX/data", "$BITNAMI_APP_VOL_PREFIX/conf", "$BITNAMI_APP_VOL_PREFIX/logs"]
ENTRYPOINT ["/entrypoint.sh"]

175
bitnami/mongodb/README.md
View File

@@ -7,14 +7,14 @@
# TLDR
```bash
docker run --name mongodb bitnami/mongodb
docker run --name mongodb bitnami/mongodb:latest
```
## Docker Compose
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
```
# Get this image
@@ -34,31 +34,30 @@ docker pull bitnami/mongodb:[TAG]
If you wish, you can also build the image yourself.
```bash
git clone https://github.com/bitnami/bitnami-docker-mongodb.git
cd bitnami-docker-mongodb
docker build -t bitnami/mongodb .
docker build -t bitnami/mongodb:latest https://github.com/bitnami/bitnami-docker-mongodb.git
```
# Persisting your database
If you remove the container all your data will be lost, and the next time you run the image the database will be reinitialized. To avoid this loss of data, you should mount a volume that will persist even after the container is removed.
If you remove the container all your data and configurations will be lost, and the next time you run the image the database will be reinitialized. To avoid this loss of data, you should mount a volume that will persist even after the container is removed.
**Note!**
If you have already started using your database, follow the steps on [backing up](#backing-up-your-container) and [restoring](#restoring-a-backup) to pull the data from your running container down to your host.
If you have already started using your database, follow the steps on
[backing up](#backing-up-your-container) and [restoring](#restoring-a-backup) to pull the data from your running container down to your host.
The MongoDB image exposes a volume at `/bitnami/mongodb/data`, you can mount a directory from your host to serve as the data store. If the directory you mount is empty, the database will be initialized.
The image exposes a volume at `/bitnami/mongodb` for the MongoDB data and configurations. For persistence you can mount a directory at this location from your host. If the mounted directory is empty, it will be initialized on the first run.
```bash
docker run -v /path/to/data:/bitnami/mongodb/data bitnami/mongodb
docker run -v /path/to/mongodb-persistence:/bitnami/mongodb bitnami/mongodb:latest
```
or using Docker Compose:
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
volumes:
- /path/to/data:/bitnami/mongodb/data
- /path/to/mongodb-persistence:/bitnami/mongodb
```
# Linking
@@ -74,7 +73,7 @@ The first step is to start our MongoDB server.
Docker's linking system uses container ids or names to reference containers. We can explicitly specify a name for our MongoDB server to make it easier to connect to other containers.
```bash
docker run --name mongodb bitnami/mongodb
docker run --name mongodb bitnami/mongodb:latest
```
### Step 2: Run MongoDB as a Mongo client and link to our server
@@ -84,7 +83,7 @@ Now that we have our MongoDB server running, we can create another container tha
The Bitnami MongoDB Docker Image also ships with a Mongo client, but by default it will start a server. To start the client instead, we can override the default command Docker runs by stating a different command to run after the image name.
```bash
docker run --rm -it --link mongodb:server bitnami/mongodb mongo --host server
docker run --rm -it --link mongodb:server bitnami/mongodb:latest mongo --host server
```
We started the Mongo client passing in the `--host` option that allows us to specify the hostname of the server, which we set to the hostname we created in the link.
@@ -102,16 +101,16 @@ docker exec -it mongodb mongo
Copy the snippet below into your `docker-compose.yml` to add MongoDB to your application.
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
```
### Step 2: Link it to another container in your application
Update the definitions for containers you want to access your MongoDB server from to include a link to the `mongodb` entry you added in Step 1.
```
```yaml
myapp:
image: myapp
links:
@@ -124,41 +123,39 @@ Inside `myapp`, use `mongodb` as the hostname for the MongoDB server.
## Setting the root password on first run
Passing the `MONGODB_PASSWORD` environment variable when running the image for the first time will set the password of the root user to the value of `MONGODB_PASSWORD`.
Passing the `MONGODB_ROOT_PASSWORD` environment variable when running the image for the first time will set the password of the root user to the value of `MONGODB_ROOT_PASSWORD` and enabled authentication on the MongoDB server.
```bash
docker run --name mongodb -e MONGODB_PASSWORD=password123 bitnami/mongodb
docker run --name mongodb \
-e MONGODB_ROOT_PASSWORD=password123 bitnami/mongodb:latest
```
or using Docker Compose:
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
environment:
- MONGODB_PASSWORD=password123
- MONGODB_ROOT_PASSWORD=password123
```
The `root` user is configured to have full administrative access to the MongoDB server. When `MONGODB_PASSWORD` is not specified the server allows unauthenticated and unrestricted access.
**Note!**
The `MONGODB_PASSWORD` enables authentication on the MongoDB server at runtime. Ensure that this parameter is **always** specified to ensure that authentication is enabled each time the container is started.
The `root` user is configured to have full administrative access to the MongoDB server. When `MONGODB_ROOT_PASSWORD` is not specified the server allows unauthenticated and unrestricted access.
## Creating a user and database on first run
You can create a user with restricted access to a database while starting the container for the first time. To do this, provide the `MONGODB_USER`, `MONGO_PASSWORD` and `MONGODB_DATABASE` environment variables.
**Warning!** In this case, a root user will not be created, and your restricted user will not have permissions to create a new database.
```bash
docker run --name mongodb -e MONGODB_USER=my_user -e MONGODB_PASSWORD=password123 -e MONGODB_DATABASE=my_database bitnami/mongodb
docker run --name mongodb \
-e MONGODB_USER=my_user -e MONGODB_PASSWORD=password123 \
-e MONGODB_DATABASE=my_database bitnami/mongodb:latest
```
or using Docker Compose:
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
environment:
- MONGODB_USER=my_user
- MONGODB_PASSWORD=password123
@@ -166,49 +163,27 @@ mongodb:
```
**Note!**
When `MONGODB_PASSWORD` is specified along with `MONGODB_USER`, the value specified in `MONGODB_PASSWORD` is set as the password of the newly created user specified in `MONGODB_USER`.
## Command-line options
The simplest way to configure your MongoDB server is to pass custom command-line options when running the image.
```bash
docker run -it --rm bitnami/mongodb --maxConns=1000
```
or using Docker Compose:
```
mongodb:
image: bitnami/mongodb
command: --maxConns=1000
```
**Further Reading:**
- [MongoDB Server Command Options](http://docs.mongodb.org/manual/reference/program/mongod/)
- [MongoDB Server Parameters](http://docs.mongodb.org/manual/reference/parameters/#mongodb-server-parameters)
- [Caveats](#caveats)
Creation of a user enables authentication on the MongoDB server and as a result unauthenticated access by *any* user is not permitted.
## Configuration file
This image looks for the configuration in `/bitnami/mongodb/conf`. You can mount a volume there with your own configuration, or the default configuration will be copied to your volume if it is empty.
The image looks for configuration in the `conf/` directory of `/bitnami/mongodb`. As as mentioned in [Persisting your database](#persisting-your-data) you can mount a volume at this location and copy your own configurations in the `conf/` directory. The default configuration will be copied to the `conf/` directory if it's empty.
### Step 1: Run the MongoDB image
Run the MongoDB image, mounting a directory from your host.
```bash
docker run --name mongodb -v /path/to/mongodb/conf:/bitnami/mongodb/conf bitnami/mongodb
docker run --name mongodb -v /path/to/mongodb-persistence:/bitnami/mongodb bitnami/mongodb:latest
```
or using Docker Compose:
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
volumes:
- /path/to/mongodb/conf:/bitnami/mongodb/conf
- /path/to/mongodb-persistence:/bitnami/mongodb
```
### Step 2: Edit the configuration
@@ -216,7 +191,7 @@ mongodb:
Edit the configuration on your host using your favorite editor.
```bash
vi /path/to/mongodb/conf/mongodb.conf
vi /path/to/mongodb-persistence/conf/mongodb.conf
```
### Step 3: Restart MongoDB
@@ -236,24 +211,10 @@ docker-compose restart mongodb
**Further Reading:**
- [Configuration File Options](http://docs.mongodb.org/v2.4/reference/configuration-options/)
- [Caveats](#caveats)
## Caveats
The following options should not be modified, to ensure that the image runs correctly.
```bash
--config /opt/bitnami/mongodb/conf/mongodb.conf
--dbpath /opt/bitnami/mongodb/data
```
# Logging
The Bitnami MongoDB Docker Image supports two different logging modes: logging to stdout, and logging to a file.
## Logging to stdout
The default behavior is to log to stdout, as Docker expects. These will be collected by Docker, converted to JSON and stored in the host, to be accessible via the `docker logs` command.
The Bitnami MongoDB Docker image sends the container logs to the `stdout`. To view the logs:
```bash
docker logs mongodb
@@ -265,26 +226,7 @@ or using Docker Compose:
docker-compose logs mongodb
```
This method of logging has the downside of not being easy to manage. Without an easy way to rotate logs, they could grow exponentially and take up large amounts of disk space on your host.
## Logging to file
To log to file, run the MongoDB image, mounting a directory from your host at `/bitnami/mongodb/logs`. This will instruct the container to send logs to a `mongodb.log` file in the mounted volume.
```bash
docker run --name mongodb -v /path/to/mongodb/logs:/bitnami/mongodb/logs bitnami/mongodb
```
or using Docker Compose:
```
mongodb:
image: bitnami/mongodb
volumes:
- /path/to/mongodb/logs:/bitnami/mongodb/logs
```
To perform operations (e.g. logrotate) on the logs, mount the same directory in a container designed to operate on log files, such as logstash.
You can configure the containers [logging driver](https://docs.docker.com/engine/admin/logging/overview/) using the `--log-driver` option if you wish to consume the container logs differently. In the default configuration docker uses the `json-file` driver.
# Maintenance
@@ -309,40 +251,37 @@ docker-compose stop mongodb
We need to mount two volumes in a container we will use to create the backup: a directory on your host to store the backup in, and the volumes from the container we just stopped so we can access the data.
```bash
docker run --rm -v /path/to/backups:/backups --volumes-from mongodb busybox \
cp -a /bitnami/mongodb /backups/latest
docker run --rm \
-v /path/to/mongodb-backups:/backups \
--volumes-from mongodb busybox \
cp -a /bitnami/mongodb:latest /backups/latest
```
or using Docker Compose:
```bash
docker run --rm -v /path/to/backups:/backups --volumes-from `docker-compose ps -q mongodb` busybox \
cp -a /bitnami/mongodb /backups/latest
docker run --rm \
-v /path/to/mongodb-backups:/backups \
--volumes-from `docker-compose ps -q mongodb` busybox \
cp -a /bitnami/mongodb:latest /backups/latest
```
**Note!**
If you only need to backup database data, or configuration, you can change the first argument to `cp` to `/bitnami/mongodb/data` or `/bitnami/mongodb/conf` respectively.
## Restoring a backup
Restoring a backup is as simple as mounting the backup as volumes in the container.
```bash
docker run -v /path/to/backups/latest/data:/bitnami/mongodb/data \
-v /path/to/backups/latest/conf:/bitnami/mongodb/conf \
-v /path/to/backups/latest/logs:/bitnami/mongodb/logs \
bitnami/mongodb
docker run \
-v /path/to/mongodb-backups/latest:/bitnami/mongodb bitnami/mongodb:latest
```
or using Docker Compose:
```
```yaml
mongodb:
image: bitnami/mongodb
image: bitnami/mongodb:latest
volumes:
- /path/to/backups/latest/data:/bitnami/mongodb/data
- /path/to/backups/latest/conf:/bitnami/mongodb/conf
- /path/to/backups/latest/logs:/bitnami/mongodb/logs
- /path/to/mongodb-backups/latest:/bitnami/mongodb
```
## Upgrade this image
@@ -393,10 +332,17 @@ docker-compose start mongodb
This image is tested for expected runtime behavior, using the [Bats](https://github.com/sstephenson/bats) testing framework. You can run the tests on your machine using the `bats` command.
```
```bash
bats test.sh
```
# Notable Changes
## 3.2.6-r0
- All volumes have been merged at `/bitnami/mongodb`. Now you only need to mount a single volume at `/bitnami/mongodb` for persistence.
- The logs are always sent to the `stdout` and are no longer collected in the volume.
# Contributing
We'd love for you to contribute to this container. You can request new features by creating an [issue](https://github.com/bitnami/bitnami-docker-mongodb/issues), or submit a [pull request](https://github.com/bitnami/bitnami-docker-mongodb/pulls) with your contribution.
@@ -409,8 +355,7 @@ If you encountered a problem running this container, you can file an [issue](htt
- Docker version (`docker version`)
- Output of `docker info`
- Version of this container (`echo $BITNAMI_APP_VERSION` inside the container)
- The command you used to run the container, and any relevant output you saw (masking any sensitive
information)
- The command you used to run the container, and any relevant output you saw (masking any sensitive information)
# License

27
bitnami/mongodb/help.txt
View File

@@ -1,27 +0,0 @@
$BITNAMI_APP_NAME cheatsheet:
ENVIRONMENT VARIABLES:
MONGODB_USER: User to be created on first boot (default: root).
MONGODB_PASSWORD: Password to be set for MONGODB_USER on first boot (default: none).
MONGODB_DATABASE: Database to be created on first boot, accessible by MONGODB_USER (default: none).
VOLUMES:
$BITNAMI_APP_VOL_PREFIX/data: Location of $BITNAMI_APP_NAME data files.
$BITNAMI_APP_VOL_PREFIX/conf: Location of mongodb.conf ($BITNAMI_APP_NAME config file).
$BITNAMI_APP_VOL_PREFIX/logs: Location of mongodb.log.
PORTS:
27017: Default $BITNAMI_APP_NAME port.
MISC:
Options: You can add extra options during the docker run using the -- prefix.
Note: MONGODB_USER works in conjunction with MONGODB_DATABASE environment variable.
Tip: Back up the $BITNAMI_APP_VOL_PREFIX/data and $BITNAMI_APP_VOL_PREFIX/conf directories regularly.
COMMANDS:
print-help: Print this page.
check-updates: Check if a new version of the $BITNAMI_APP_NAME image is available.
Visit $GITHUB_PAGE for more information.

15
bitnami/mongodb/help.yaml
View File

@@ -1,15 +0,0 @@
environment_variables:
MONGODB_USER: "User to be created on first boot (default: root)."
MONGODB_PASSWORD: "Password to be set for MONGODB_USER on first boot (default: none)."
MONGODB_DATABASE: "Database to be created on first boot, accessible by MONGODB_USER (default: none)."
volumes:
$BITNAMI_APP_VOL_PREFIX/data: "Location of $BITNAMI_APP_NAME data files."
$BITNAMI_APP_VOL_PREFIX/conf: "Location of mongodb.conf ($BITNAMI_APP_NAME config file)."
$BITNAMI_APP_VOL_PREFIX/logs: "Location of mongodb.log."
ports:
27017: "Default $BITNAMI_APP_NAME port."
misc:
Options: "You can add extra options during the docker run using the -- prefix."
Note: "The user and database creation happens only the first time you run the container."
Note: "MONGODB_USER works in conjunction with MONGODB_DATABASE environment variable."
Tip: "Back up the $BITNAMI_APP_VOL_PREFIX/data and $BITNAMI_APP_VOL_PREFIX/conf directories regularly."

1
bitnami/mongodb/installer.run.sha256
View File

@@ -1 +0,0 @@
5056141d3ab3c5cfdc8c7b813f5e82aef9b549d32f45fc7efe53fb376dc2cba7 /tmp/installer.run

17
bitnami/mongodb/post-install.sh
View File

@@ -1,17 +0,0 @@
#!/bin/bash
set -e
cd $BITNAMI_APP_DIR
# set up default config
mkdir $BITNAMI_APP_DIR/conf.defaults
mv $BITNAMI_APP_DIR/mongodb.conf $BITNAMI_APP_DIR/conf.defaults
ln -s $BITNAMI_APP_DIR/conf/mongodb.conf $BITNAMI_APP_DIR/mongodb.conf
# symlink mount points at root to install dir
ln -s $BITNAMI_APP_DIR/conf $BITNAMI_APP_VOL_PREFIX/conf
ln -s $BITNAMI_APP_DIR/data $BITNAMI_APP_VOL_PREFIX/data
ln -s $BITNAMI_APP_DIR/log $BITNAMI_APP_VOL_PREFIX/logs
# nullify `ctl.sh` script administered by `bnconfig`
echo "# Disabled" > $BITNAMI_APP_DIR/scripts/ctl.sh

16
bitnami/mongodb/rootfs/app-entrypoint.sh Executable file
View File

@@ -0,0 +1,16 @@
#!/bin/bash
set -e
if [[ "$1" == "harpoon" && "$2" == "start" ]]; then
status=`harpoon inspect $BITNAMI_APP_NAME`
if [[ "$status" == *'"lifecycle": "unpacked"'* ]]; then
harpoon initialize $BITNAMI_APP_NAME \
${MONGODB_ROOT_PASSWORD:+--rootPassword $MONGODB_ROOT_PASSWORD} \
${MONGODB_USER:+--username $MONGODB_USER} \
${MONGODB_PASSWORD:+--password $MONGODB_PASSWORD} \
${MONGODB_DATABASE:+--database $MONGODB_DATABASE}
fi
chown $BITNAMI_APP_USER: /bitnami/$BITNAMI_APP_NAME || true
fi
exec /entrypoint.sh "$@"

91
bitnami/mongodb/rootfs/bitnami-utils-custom.sh
View File

@@ -1,91 +0,0 @@
# MongoDB Utility functions
PROGRAM_OPTIONS="--config $BITNAMI_APP_DIR/conf/mongodb.conf --dbpath $BITNAMI_APP_DIR/data"
create_mongodb_user() {
if [ "$MONGODB_USER" ] && [ -z $MONGODB_PASSWORD ]; then
echo ""
echo "In order to create a MONGODB_USER you need to provide the MONGODB_PASSWORD as well"
echo ""
exit -1
elif [ -z $MONGODB_PASSWORD ]; then
return 0
fi
MONGODB_USER=${MONGODB_USER:-root}
if [ "$MONGODB_USER" != "root" ] && [ ! $MONGODB_DATABASE ]; then
echo ""
echo "In order to use a custom MONGODB_USER you need to provide the MONGODB_DATABASE as well"
echo ""
exit -1
fi
echo ""
echo "==> Creating user $MONGODB_USER..."
# start mongodb server and wait for it to accept connections
mongod $PROGRAM_OPTIONS --logpath /dev/null --bind_ip 127.0.0.1 --fork >/dev/null
timeout=10
while ! mongo --eval "db.adminCommand('listDatabases')" >/dev/null 2>&1
do
timeout=$(($timeout - 1))
if [ $timeout -eq 0 ]; then
echo "Could not connect to server. Aborting..."
exit 1
fi
sleep 1
done
if [ "$MONGODB_USER" == "root" ]; then
cat >> /tmp/initMongo.js <<EOF
db = db.getSiblingDB('admin')
db.createUser(
{
user: "$MONGODB_USER",
pwd: "$MONGODB_PASSWORD",
roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
}
)
EOF
fi
if [ $MONGODB_DATABASE ]; then
cat >> /tmp/initMongo.js <<EOF
db = db.getSiblingDB('$MONGODB_DATABASE')
db.createUser(
{
user: "$MONGODB_USER",
pwd: "$MONGODB_PASSWORD",
roles: [ { role: "readWrite", db: "$MONGODB_DATABASE" } ]
}
)
EOF
fi
mongo /tmp/initMongo.js >/dev/null
mongod $PROGRAM_OPTIONS --shutdown >/dev/null
# enable authentication in mongo configuration
echo "auth = true" >> $BITNAMI_APP_DIR/conf/mongodb.conf
}
print_mongo_user() {
if [ -z $MONGODB_USER ]; then
echo "**none**"
else
echo $MONGODB_USER
fi
}
print_mongo_password() {
if [ -z $MONGODB_PASSWORD ]; then
echo "**none**"
else
echo $MONGODB_PASSWORD
fi
}
print_mongo_database() {
if [ $MONGODB_DATABASE ]; then
echo "Database: $MONGODB_DATABASE"
fi
}

18
bitnami/mongodb/rootfs/etc/cont-init.d/01-bitnami-mongodb
View File

@@ -1,18 +0,0 @@
#!/usr/bin/with-contenv bash
set -e
source $BITNAMI_PREFIX/bitnami-utils.sh
if [ ! "$(ls -A $BITNAMI_APP_VOL_PREFIX/conf)" ]; then
generate_conf_files
fi
if [ ! -f $BITNAMI_APP_VOL_PREFIX/data/storage.bson ]; then
create_mongodb_user
print_app_credentials $BITNAMI_APP_NAME `print_mongo_user` `print_mongo_password` `print_mongo_database`
else
print_container_already_initialized $BITNAMI_APP_NAME
fi
chown -R $BITNAMI_APP_USER:$BITNAMI_APP_USER $BITNAMI_APP_VOL_PREFIX/data/ \
$BITNAMI_APP_VOL_PREFIX/logs/ \
$BITNAMI_APP_VOL_PREFIX/conf/ || true

1
bitnami/mongodb/rootfs/etc/services.d/mongodb-logs/finish
View File

@@ -1 +0,0 @@
/bin/true

5
bitnami/mongodb/rootfs/etc/services.d/mongodb-logs/run
View File

@@ -1,5 +0,0 @@
#!/usr/bin/with-contenv bash
set -e
source $BITNAMI_PREFIX/bitnami-utils.sh
exec s6-setuidgid $BITNAMI_APP_USER tail -f -n 1000 $BITNAMI_APP_VOL_PREFIX/logs/*.log 2>/dev/null

21
bitnami/mongodb/rootfs/etc/services.d/mongodb/finish
View File

@@ -1,21 +0,0 @@
#!/usr/bin/with-contenv bash
failcount=0
if [ -f $BITNAMI_APP_DIR/tmp/failcount ]; then
failcount=$(cat $BITNAMI_APP_DIR/tmp/failcount)
fi
start=$(cat $BITNAMI_APP_DIR/tmp/start)
stop=`date '+%d%H%M%S'`
interval=`expr $stop - $start`
if test $interval -lt 30 ; then
failcount=`expr $failcount + 1`
else
failcount=0
fi
echo -n $failcount > $BITNAMI_APP_DIR/tmp/failcount
# bring down container on frequent failures. something is definitely wrong
if test $failcount -ge 3 ; then
s6-svscanctl -t /var/run/s6/services
fi

9
bitnami/mongodb/rootfs/etc/services.d/mongodb/run
View File

@@ -1,9 +0,0 @@
#!/usr/bin/with-contenv bash
set -e
source $BITNAMI_PREFIX/bitnami-utils.sh
mkdir -p $BITNAMI_APP_DIR/tmp
date '+%d%H%M%S' > $BITNAMI_APP_DIR/tmp/start
rm -rf $BITNAMI_APP_VOL_PREFIX/data/mongod.lock
exec s6-setuidgid $BITNAMI_APP_USER $BITNAMI_APP_DAEMON $PROGRAM_OPTIONS ${MONGODB_PASSWORD:+--auth} ${EXTRA_OPTIONS:+"$EXTRA_OPTIONS"}

194
bitnami/mongodb/test.sh
View File

@@ -1,13 +1,14 @@
#!/usr/bin/env bats
MONGODB_ROOT_USER=root
MONGODB_DATABASE=test_database
MONGODB_USER=test_user
MONGODB_PASSWORD=test_password
# source the helper script
APP_NAME=mongodb
SLEEP_TIME=5
VOL_PREFIX=/bitnami/$APP_NAME
VOLUMES=$VOL_PREFIX
SLEEP_TIME=30
load tests/docker_helper
# Link to container and execute mongo client
@@ -33,154 +34,137 @@ cleanup_environment
@test "Port 27017 exposed and accepting external connections" {
container_create default -d
# ping the mongod server
run mongo_client default ping
[[ "$output" =~ "bye" ]]
run mongo_client default admin --eval "printjson(db.adminCommand('ping'))"
[[ "$output" =~ '"ok" : 1' ]]
}
@test "Can't create root user without password" {
# create container without specifying MONGODB_PASSWORD for root user
run container_create default \
-e MONGODB_USER=$MONGODB_ROOT_USER
[[ "$output" =~ "you need to provide the MONGODB_PASSWORD" ]]
}
@test "Root user created with password" {
container_create default -d \
-e MONGODB_USER=$MONGODB_ROOT_USER \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
# auth as root without specifying password
run mongo_client default -u $MONGODB_ROOT_USER admin --eval "printjson(db.adminCommand('listDatabases'))"
[[ "$output" =~ "login failed" ]]
# auth as root and list all databases
run mongo_client default -u $MONGODB_ROOT_USER -p $MONGODB_PASSWORD admin --eval "printjson(db.adminCommand('listDatabases'))"
@test "Can login without a password" {
container_create default -d
run mongo_client default admin --eval "printjson(db.adminCommand('listDatabases'))"
[[ "$output" =~ '"ok" : 1' ]]
[[ "$output" =~ '"name" : "local"' ]]
}
@test "Can't create a custom user without password" {
# create custom user without specifying MONGODB_PASSWORD
@test "Authentication is enabled if root password is specified" {
container_create default -d \
-e MONGODB_ROOT_PASSWORD=$MONGODB_PASSWORD
run mongo_client default admin --eval "printjson(db.adminCommand('listDatabases'))"
[[ "$output" =~ "not authorized on admin to execute command" ]]
}
@test "Root user created with custom password" {
container_create default -d \
-e MONGODB_ROOT_PASSWORD=$MONGODB_PASSWORD
run mongo_client default -u root -p $MONGODB_PASSWORD admin --eval "printjson(db.adminCommand('listDatabases'))"
[[ "$output" =~ '"ok" : 1' ]]
[[ "$output" =~ '"name" : "admin"' ]]
}
@test "Can't set root user password with MONGODB_PASSWORD" {
run container_create default \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
[[ "$output" =~ "If you defined a password or a database you should define an username too" ]]
}
@test "Can't create custom user without a password" {
run container_create default \
-e MONGODB_USER=$MONGODB_USER
[[ "$output" =~ "you need to provide the MONGODB_PASSWORD" ]]
[[ "$output" =~ "If you defined an username you must define a password and a database too" ]]
}
@test "Can't create a custom user without database" {
# create custom user without specifying MONGODB_DATABASE
@test "Can't create custom user without database" {
run container_create default \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
[[ "$output" =~ "you need to provide the MONGODB_DATABASE" ]]
-e MONGODB_PASSWORD=$MONGODB_PASSWORD \
[[ "$output" =~ "If you defined an username you must define a password and a database too" ]]
}
@test "Create custom user and database with password" {
@test "Custom user created with password" {
container_create default -d \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_DATABASE=$MONGODB_DATABASE \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
-e MONGODB_PASSWORD=$MONGODB_PASSWORD \
-e MONGODB_DATABASE=$MONGODB_DATABASE
# auth as MONGODB_USER without specifying MONGODB_PASSWORD
run mongo_client default -u $MONGODB_USER $MONGODB_DATABASE --eval "printjson(db.adminCommand('listCollections'))"
[[ "$output" =~ "login failed" ]]
# auth as MONGODB_USER and list all Collections from MONGODB_DATABASE
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.adminCommand('listCollections'))"
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.createCollection('users'))"
[[ "$output" =~ '"ok" : 1' ]]
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.getCollectionNames())"
[[ "$output" =~ '"users"' ]]
}
@test "Custom user can't access admin database" {
container_create default -d \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_DATABASE=$MONGODB_DATABASE \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
-e MONGODB_PASSWORD=$MONGODB_PASSWORD \
-e MONGODB_DATABASE=$MONGODB_DATABASE
# auth as MONGODB_USER and list all databases
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD admin --eval "printjson(db.adminCommand('listDatabases'))"
[[ "$output" =~ 'login failed' ]]
[[ "$output" =~ "login failed" ]]
}
@test "Can set root password and create custom user" {
container_create default -d \
-e MONGODB_ROOT_PASSWORD=$MONGODB_PASSWORD \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD \
-e MONGODB_DATABASE=$MONGODB_DATABASE
run mongo_client default -u root -p $MONGODB_PASSWORD admin --eval "printjson(db.adminCommand('listDatabases'))"
[[ "$output" =~ '"ok" : 1' ]]
[[ "$output" =~ '"name" : "admin"' ]]
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.createCollection('users'))"
[[ "$output" =~ '"ok" : 1' ]]
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.getCollectionNames())"
[[ "$output" =~ '"users"' ]]
}
@test "Settings and data are preserved on container restart" {
container_create default -d \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD \
-e MONGODB_DATABASE=$MONGODB_DATABASE
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.createCollection('users'))"
[[ "$output" =~ '"ok" : 1' ]]
container_restart default
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.getCollectionNames())"
[[ "$output" =~ '"users"' ]]
}
@test "All the volumes exposed" {
container_create default -d
# get container introspection details and check if volumes are exposed
run container_inspect default --format {{.Mounts}}
[[ "$output" =~ "$VOL_PREFIX/data" ]]
[[ "$output" =~ "$VOL_PREFIX/conf" ]]
[[ "$output" =~ "$VOL_PREFIX/logs" ]]
[[ "$output" =~ "$VOL_PREFIX" ]]
}
@test "Data gets generated in conf, data and logs if bind mounted in the host" {
container_create_with_host_volumes default -d \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_DATABASE=$MONGODB_DATABASE \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
@test "Data gets generated in volume if bind mounted" {
container_create_with_host_volumes default -d
# files expected in conf volume
run container_exec default ls -la $VOL_PREFIX/conf/
[[ "$output" =~ "mongodb.conf" ]]
# files expected in data volume (subset)
run container_exec default ls -la $VOL_PREFIX/data/
run container_exec default ls -la $VOL_PREFIX/data/db/
[[ "$output" =~ "storage.bson" ]]
# files expected in logs volume
run container_exec default ls -la $VOL_PREFIX/logs/
[[ "$output" =~ "mongodb.log" ]]
}
@test "User and password settings are preserved after restart" {
container_create default -d \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_DATABASE=$MONGODB_DATABASE \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
# restart container
container_restart default
# get container logs
run container_logs default
[[ "$output" =~ "The credentials were set on first boot." ]]
# auth as MONGODB_USER and list all Collections from MONGODB_DATABASE
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.adminCommand('listCollections'))"
[[ "$output" =~ '"ok" : 1' ]]
}
@test "If host mounted, password and settings are preserved after deletion" {
@test "If host mounted, setting and data are preserved after deletion" {
container_create_with_host_volumes default -d \
-e MONGODB_USER=$MONGODB_USER \
-e MONGODB_DATABASE=$MONGODB_DATABASE \
-e MONGODB_PASSWORD=$MONGODB_PASSWORD
-e MONGODB_PASSWORD=$MONGODB_PASSWORD \
-e MONGODB_DATABASE=$MONGODB_DATABASE
# stop and remove container
container_remove default
# recreate container without specifying any env parameters
container_create_with_host_volumes default -d
# auth as MONGODB_USER and list all Collections from MONGODB_DATABASE
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.adminCommand('listCollections'))"
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.createCollection('users'))"
[[ "$output" =~ '"ok" : 1' ]]
}
@test "Configuration changes are preserved after deletion" {
container_create_with_host_volumes default -d
# modify mongodb.conf
container_exec default sed -i 's|^[#]*[ ]*bind_ip[ ]*=.*|bind_ip=0.0.0.0|' $VOL_PREFIX/conf/mongodb.conf
container_exec default sed -i 's|^[#]*[ ]*logappend[ ]*=.*|logappend=false|' $VOL_PREFIX/conf/mongodb.conf
container_exec default sed -i 's|^[#]*[ ]*cpu[ ]*=.*|cpu=false|' $VOL_PREFIX/conf/mongodb.conf
# stop and remove container
container_remove default
# relaunch container with host volumes
container_create_with_host_volumes default -d
run container_exec default cat $VOL_PREFIX/conf/mongodb.conf
[[ "$output" =~ "bind_ip=0.0.0.0" ]]
[[ "$output" =~ "logappend=false" ]]
[[ "$output" =~ "cpu=false" ]]
run mongo_client default -u $MONGODB_USER -p $MONGODB_PASSWORD $MONGODB_DATABASE --eval "printjson(db.getCollectionNames())"
[[ "$output" =~ '"users"' ]]
}