Bitnami/containers
2
0
Fork 0
mirror of https://github.com/bitnami/containers.git synced 2026-03-05 16:17:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #12 from bitnami/4.5

Browse Source 
Release WordPress 4.5.2 Harpoon Module
This commit is contained in:
vosgaust
2016-05-20 16:23:38 +02:00
parent 1a4f9b9b2d ad5f1d5298
commit bf80fa99e9
6 changed files with 278 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
bitnami/wordpress/Dockerfile
View File

@@ -1,16 +1,26 @@
FROM bitnami/base-apps-ubuntu:14.04
FROM gcr.io/stacksmith-images/ubuntu:14.04-r07
MAINTAINER Bitnami <containers@bitnami.com>
ENV BITNAMI_APP_NAME=wordpress \
BITNAMI_APP_VERSION=4.5-0 \
BITNAMI_APP_USER=bitnami \
BITNAMI_APPLICATION_USER=user \
BITNAMI_APPLICATION_PASSWORD=bitnami \
IS_BITNAMI_STACK=1
BITNAMI_APP_VERSION=4.5.2 \
PATH=/opt/bitnami/php/bin:/opt/bitnami/drush:/opt/bitnami/mysql/bin/:$PATH
#Download latest WordPress Stack from bitnami.com
RUN $BITNAMI_PREFIX/install.sh \
--base_user $BITNAMI_APPLICATION_USER --base_password $BITNAMI_APPLICATION_PASSWORD --apache_mpm_mode event --enable_phpfpm 1 --logrotate_install 1 && \
rm $BITNAMI_PREFIX/install.sh
# Additional modules required
RUN bitnami-pkg install php-5.6.21-0 --checksum 1e0ebe2f26edea96b583d8b7ba2bf895b3c03ea40d67dfb1df3bf331c9caad6c
RUN bitnami-pkg unpack apache-2.4.18-2 --checksum 9722f4f470e036b4ed4f0fe98509e24f7182177b54a268a458af5eb8e7e6370a
RUN bitnami-pkg install libphp-5.6.21-0 --checksum 8c1f994108eb17c69b00ac38617997b8ffad7a145a83848f38361b9571aeb73e
RUN bitnami-pkg install mysql-client-10.1.13-1 --checksum e16c0ace5cb779b486e52af83a56367f26af16a25b4ab92d8f4293f1bf307107
EXPOSE 80 443 22
# Install wordpress
RUN bitnami-pkg unpack wordpress-4.5.2-0 --checksum 6908a643c55665564f1e5ee0c868de3c00e39231b4f90cee8511d379557cabac
COPY rootfs /
VOLUME ["/bitnami/wordpress", "/bitnami/apache"]
EXPOSE 80 443
ENTRYPOINT ["/app-entrypoint.sh"]
CMD ["harpoon", "start", "--foreground", "apache"]

275
bitnami/wordpress/README.md
View File

@@ -1,120 +1,235 @@
[![Build Status](http://bitnami-container-builds.bitnamiapp.com/jenkins/buildStatus/icon?job=docker-wordpress)](http://bitnami-container-builds.bitnamiapp.com/jenkins/job/docker-wordpress/)
# What is WordPress?
# Bitnami Docker Image for WordPress
This is an all-in-one container for [Bitnami WordPress Stack](https://bitnami.com/stack/wordpress). It includes all the required dependencies to run WordPress in a container in less than 1 minute.
> WordPress is one of the most versatile open source content management systems on the market. WordPress is built for high performance and is scalable to many servers, has easy integration via REST, JSON, SOAP and other formats, and features a whopping 15,000 plugins to extend and customize the application for just about any type of website.
https://www.wordpress.org/
# Prerequisites
To run this application you need Docker Engine 1.10.0. Docker Compose is recomended with a version 1.6.0 or later.
# How to use this image
## Run WordPress with a Database Container
Running WordPress with a database server is the recommended way. You can either use docker-compose or run the containers manually.
### Run the application using Docker Compose
This is the recommended way to run WordPress. You can use the following docker compose template:
# TLDR
```
docker run --name=wordpress -p 80:80 -p 443:443 bitnami/wordpress
```
The application is configured with default credentials `user` / `bitnami`.
version: '2'
# Get this image
services:
mariadb:
image: bitnami/mariadb:latest
volumes_from:
- mariadb_data
The recommended way to get the Bitnami Docker Image for WordPress is to pull the prebuilt image from the [Docker Hub Registry](https://hub.docker.com/r/bitnami/wordpress).
mariadb_data:
image: bitnami/mariadb:latest
entrypoint: 'true'
```bash
docker pull bitnami/wordpress:latest
application:
build: bitnami/wordpress:latest
ports:
- 80:80
- 443:443
volumes_from:
- application_data
depends_on:
- mariadb
application_data:
image: bitnami/wordpress:latest
volumes:
- /bitnami/wordpress
- /bitnami/apache
entrypoint: 'true'
```
To use a specific version, you can pull a versioned tag. You can view the
[list of available versions](https://hub.docker.com/r/bitnami/wordpress/tags/)
in the Docker Hub Registry.
### Run the application manually
```bash
docker pull bitnami/wordpress:[TAG]
If you want to run the application manually instead of using docker-compose, these are the basic steps you need to run:
1. Create a new network for the application and the database:
```
$ docker network create wordpress_network
```
2. Start a MariaDB database in the network generated:
```
$ docker run -d --name mariadb --net=wordpress_network bitnami/mariadb
```
*Note:* You need to give the container a name in order to WordPress to resolve the host
3. Run the WordPress container:
```
$ docker run -d -p 80:80 --name wordpress --net=wordpress_network bitnami/wordpress
```
Then you can access your application at http://your-ip/
## Persisting your application
If you remove every container all your data will be lost, and the next time you run the image the application 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 are using docker-compose your data will be persistent as long as you don't remove `mariadb_data` and `application_data` containers. Those are data volume containers (See https://docs.docker.com/engine/userguide/containers/dockervolumes/ for more information). If you have run the containers manually or you want to mount the folders with persistent data in your host follow the next steps:
> **Note!** If you have already started using your application, follow the steps on [backing](#backing-up-your-application) up to pull the data from your running container down to your host.
### Mount persistent folders in the host using docker-compose
This requires a sightly modification from the template previously shown:
```
version: '2'
services:
mariadb:
image: bitnami/mariadb:latest
volumes_from:
- mariadb_data
mariadb_data:
image: bitnami/mariadb:latest
entrypoint: 'true'
volumes:
- /your/local/path/bitnami/mariadb/data:/bitnami/mariadb/data
- /your/local/path/bitnami/mariadb/conf:/bitnami/mariadb/conf
application:
image: bitnami/wordpress:latest
ports:
- 80:80
volumes_from:
- application_data
application_data:
image: bitnami/wordpress:latest
volumes:
- /bitnami/wordpress
- /bitnami/apache
entrypoint: 'true'
mounts:
- /your/local/path/bitnami/wordpress:/bitnami/wordpress
- /your/local/path/bitnami/apache:/bitnami/apache
```
If you wish, you can also build the image yourself.
### Mount persistent folders manually
In this case you need to specify the directories to mount on the run command. The process is the same than the one previously shown:
1. If you haven't done this before, create a new network for the application and the database:
```
$ docker network create wordpress_network
```
2. Start a MariaDB database in the previous network:
```
$ docker run -d --name mariadb -v /your/local/path/bitnami/mariadb/data:/bitnami/mariadb/data -v /your/local/path/bitnami/mariadb/conf:/bitnami/mariadb/conf --network=wordpress_network bitnami/mariadb
```
*Note:* You need to give the container a name in order to WordPress to resolve the host
3. Run the WordPress container:
```
$ docker run -d -p 80:80 --name wordpress -v /your/local/path/bitnami/wordpress:/bitnami/wordpress --network=wordpress_network bitnami/wordpress
```
# Upgrade this application
Bitnami provides up-to-date versions of MariaDB and WordPress, including security patches, soon after they are made upstream. We recommend that you follow these steps to upgrade your container. We will cover here the upgrade of the WordPress container. For the MariaDB upgrade see https://github.com/bitnami/bitnami-docker-mariadb/blob/master/README.md#upgrade-this-image
1. Get the updated images:
```bash
git clone https://github.com/bitnami/bitnami-docker-wordpress.git
cd bitnami-docker-wordpress
docker build -t bitnami/wordpress .
```
$ docker pull bitnami/wordpress:latest
```
2. Stop your container
* For docker-compose: `$ docker-compose stop wordpress`
* For manual execution: `$ docker stop wordpress`
3. (For non-compose execution only) Create a [backup](#backing-up-your-application) if you have not mounted the wordpress folder in the host.
4. Remove the currently running container
* For docker-compose: `$ docker-compose rm -v wordpress`
* For manual execution: `$ docker rm -v wordpress`
5. Run the new image
* For docker-compose: `$ docker-compose start wordpress`
* For manual execution ([mount](#mount-persistent-folders-manually) the directories if needed): `docker run --name wordpress bitnami/wordpress:latest`
# Configuration
## Environment variables
When you start the wordpress image, you can adjust the configuration of the instance by passing one or more environment variables either on the docker-compose file or on the docker run command line. If you want to add a new environment variable:
## Application credentials
Running the container in foreground will show some information about to access your application. If you started the
container with the flag `-d` you can retrieve it by running `docker logs wordpress`.
In case you want to change the default user and password for WordPress you would need to build the image by your own following [this steps](#get-this-image)
and modifying the line `BITNAMI_APPLICATION_PASSWORD=bitnami` in the Dockerfile before starting the build.
## Application files (optional)
If you want to make the application files accessible for modifying them you could use a volume to share these files with the host. This can be done by adding some extra options to the `docker run` command:
* For docker-compose add the variable name and value under the application section:
```
docker run --name=wordpress -v ~/wordpress-files:/opt/bitnami/apps -e USER_UID=`id -u` -p 80:80 -p 443:443 bitnami/wordpress
```
This will create a folder `wordpress-files` in your home directory exposing the folder `/opt/bitnami/apps` into the container. This folder should be empty or non existent when creating the container.
NOTE: Currently is only possible to expose `/opt/bitnami/apps`. Also setting the variable USER_UID will make the files modifiable by your current user.
# Logging
The Bitnami Docker Image for WordPress will write to stdout the information about the initialization process so it is accesible by running the command `docker logs wordpress`.
In order to check the logs from services as the HTTP server or databases you could use the following commands:
```
docker exec -it wordpress /opt/bitnami/scripts/logs.sh apache
docker exec -it wordpress /opt/bitnami/scripts/logs.sh mysql
application:
image: bitnami/wordpress:latest
ports:
- 80:80
environment:
- WORDPRESS_PASSWORD=my_password
volumes_from:
- application_data
```
# Maintenance
## Backing up your container
In order to backup your containers you could pack the `/opt/bitnami` directory and copy it to the host by running the following commands:
* For manual execution add a `-e` option with each variable and value:
```
docker exec -it wordpress /services.sh stop
docker exec -it wordpress tar -pczvf /tmp/wordpress-backup.tar.gz /opt/bitnami
docker exec -it wordpress /services.sh start
docker cp wordpress:/tmp/wordpress-backup.tar.gz /path/to/destination/directory
$ docker run -d -e WORDPRESS_PASSWORD=my_password -p 80:80 --name wordpress -v /your/local/path/bitnami/wordpress:/bitnami/wordpress --network=wordpress_network bitnami/wordpress
```
NOTE: this commands assume that your container is named `wordpress`.
## Restoring a backup
Available variables:
In order to restore a previously created backup of your container, you woild need to copy the compressed file into the container and uncompress it by following commands:
- `WORDPRESS_USERNAME`: WordPress application username. Default: **user**
- `WORDPRESS_PASSWORD`: WordPress application password. Default: **bitnami**
- `WORDPRESS_EMAIL`: WordPress application email. Default: **user@example.com**
- `MARIADB_USER`: Root user for the MariaDB database. Default: **root**
- `MARIADB_PASSWORD`: Root password for the MariaDB.
- `MARIADB_HOST`: Hostname for MariaDB server. Default: **mariadb**
- `MARIADB_PORT`: Port used by MariaDB server. Default: **3306**
# Backing up your application
To backup your application data follow these steps:
1. Stop the running container:
* For docker-compose: `$ docker-compose stop wordpress`
* For manual execution: `$ docker stop wordpress`
2. Copy the WordPress data folder in the host:
```
docker cp /path/to/wordpress-backup.tar.gz wordpress:/tmp/wordpress-backup.tar.gz
docker exec -it wordpress /services.sh stop
docker exec -it wordpress tar -xzvf /tmp/wordpress-backup.tar.gz
docker exec -it wordpress /services.sh start
$ docker cp /your/local/path/bitnami:/bitnami/wordpress
```
NOTE: this commands assume that your container is named `wordpress`.
## Upgrade this image
# Restoring a backup
This image is intended for development/testing purposes. For this reason, upgrading the individual components is not supported.
# Testing
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.
```
bats test.sh
```
To restore your application using backed up data simply mount the folder with WordPress data in the container. See [persisting your application](#persisting-your-application) section for more info.
# 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-wordpress/issues), or submit a
[pull request](https://github.com/bitnami/bitnami-docker-wordpress/pulls) with your contribution.
[issue](https://github.com/bitnami/wordpress/issues), or submit a
[pull request](https://github.com/bitnami/wordpress/pulls) with your contribution.
# Issues
If you encountered a problem running this container, you can file an
[issue](https://github.com/bitnami/bitnami-docker-wordpress/issues). For us to provide better support,
[issue](https://github.com/bitnami/wordpress/issues). For us to provide better support,
be sure to include the following information in your issue:
- Host OS and version

23
bitnami/wordpress/docker-compose.yml Normal file
View File

@@ -0,0 +1,23 @@
version: '2'
services:
mariadb:
image: 'bitnami/mariadb:latest'
volumes:
- 'mariadb_data:/bitnami/mariadb'
application:
image: 'bitnami/wordpress:latest'
ports:
- '80:80'
- '443:443'
volumes:
- 'wordpress_data:/bitnami/wordpress'
- 'apache_data:/bitnami/apache'
depends_on:
- mariadb
volumes:
mariadb_data:
driver: local
wordpress_data:
driver: local
apache_data:
driver: local

30
bitnami/wordpress/rootfs/app-entrypoint.sh Executable file
View File

@@ -0,0 +1,30 @@
#!/bin/bash
set -e
function initialize {
# Package can be "installed" or "unpacked"
status=`harpoon inspect $1`
if [[ "$status" == *'"lifecycle": "unpacked"'* ]]; then
if [[ -f /$1-inputs.json ]]; then
inputs=--inputs-file=/$1-inputs.json
fi
harpoon initialize $1 $inputs
fi
}
# Set default values
export WORDPRESS_USERNAME=${WORDPRESS_USERNAME:-"user"}
export WORDPRESS_PASSWORD=${WORDPRESS_PASSWORD:-"bitnami"}
export WORDPRESS_EMAIL=${WORDPRESS_EMAIL:-"user@example.com"}
export MARIADB_USER=${MARIADB_USER:-"root"}
export MARIADB_HOST=${MARIADB_HOST:-"mariadb"}
export MARIADB_PORT=${MARIADB_PORT:-"3306"}
if [[ "$1" == "harpoon" && "$2" == "start" ]]; then
for module in apache wordpress; do
initialize $module
done
echo "Starting application ..."
fi
exec /entrypoint.sh "$@"

9
bitnami/wordpress/rootfs/wordpress-inputs.json Normal file
View File

@@ -0,0 +1,9 @@
{
"username": "{{$global.env.WORDPRESS_USERNAME}}",
"password": "{{$global.env.WORDPRESS_PASSWORD}}",
"email": "{{$global.env.WORDPRESS_EMAIL}}",
"databaseAdminUser": "{{$global.env.MARIADB_USER}}",
"databaseAdminPassword": "{{$global.env.MARIADB_PASSWORD}}",
"databaseServerHost": "{{$global.env.MARIADB_HOST}}",
"databaseServerPort": "{{$global.env.MARIADB_PORT}}"
}

64
bitnami/wordpress/test.sh
View File

@@ -1,64 +0,0 @@
#!/usr/bin/env bats
BITNAMI_APP_NAME=wordpress
WELCOME_PAGE_TEXT="Welcome to WordPress"
CONTAINER_NAME=bitnami-$BITNAMI_APP_NAME-test
IMAGE_NAME=bitnami/$BITNAMI_APP_NAME
SLEEP_TIME=90
# Check config override from host
cleanup_running_containers() {
if [ "$(docker ps -a | grep $CONTAINER_NAME)" ]; then
docker rm -fv $CONTAINER_NAME
fi
}
setup() {
cleanup_running_containers
}
teardown() {
cleanup_running_containers
}
create_container(){
docker run -d --name $CONTAINER_NAME \
--expose 80 --expose 443 $IMAGE_NAME
echo "Waiting $SLEEP_TIME for the container to initialize"
sleep $SLEEP_TIME
}
@test "We can connect to the port 80 and 443" {
create_container
docker run --link $CONTAINER_NAME:$BITNAMI_APP_NAME --rm bitnami/$BITNAMI_APP_NAME curl -L -i http://$BITNAMI_APP_NAME:80 | {
run grep "200 OK"
[ $status = 0 ]
}
docker run --link $CONTAINER_NAME:$BITNAMI_APP_NAME --rm bitnami/$BITNAMI_APP_NAME curl -L -i -k https://$BITNAMI_APP_NAME:443 | {
run grep "200 OK"
[ $status = 0 ]
}
}
@test "Returns default page" {
create_container
docker run --link $CONTAINER_NAME:$BITNAMI_APP_NAME --rm bitnami/$BITNAMI_APP_NAME curl -L -i http://$BITNAMI_APP_NAME:80 | {
run grep "$WELCOME_PAGE_TEXT"
[ $status = 0 ]
}
docker run --link $CONTAINER_NAME:$BITNAMI_APP_NAME --rm bitnami/$BITNAMI_APP_NAME curl -L -i -k https://$BITNAMI_APP_NAME:443 | {
run grep "$WELCOME_PAGE_TEXT"
[ $status = 0 ]
}
}
@test "Logs to stdout" {
create_container
docker exec $CONTAINER_NAME bash -c '$BITNAMI_PREFIX/ctlscript.sh status' | {
run grep -v "not running"
[ $status = 0 ]
}
}