Chapter 6. Migrating Applications

Export all databases to a dump file and copy it to a local machine (into the current directory):

$ rhc ssh <v2_application_name>
$ mysqldump --skip-lock-tables -h $OPENSHIFT_MYSQL_DB_HOST -P ${OPENSHIFT_MYSQL_DB_PORT:-3306} -u ${OPENSHIFT_MYSQL_DB_USERNAME:-'admin'} \
 --password="$OPENSHIFT_MYSQL_DB_PASSWORD" --all-databases > ~/app-root/data/all.sql
$ exit

Download dbdump to your local machine:

$ mkdir mysqldumpdir
$ rhc scp -a <v2_application_name> download mysqldumpdir app-root/data/all.sql

Create a v3 mysql-persistent pod from template:

$ oc new-app mysql-persistent -p \
   MYSQL_USER=<your_V2_mysql_username> -p \
   MYSQL_PASSWORD=<your_v2_mysql_password> -p MYSQL_DATABASE=<your_v2_database_name>

Check to see if the pod is ready to use:

$ oc get pods

When the pod is up and running, copy database archive files to your v3 MySQL pod:

$ oc rsync /local/mysqldumpdir <mysql_pod_name>:/var/lib/mysql/data

Restore the database in the v3 running pod:

$ oc rsh <mysql_pod>
$ cd /var/lib/mysql/data/mysqldumpdir

In v3, to restore databases you need to access MySQL as root user.

In v2, the $OPENSHIFT_MYSQL_DB_USERNAME had full privileges on all databases. In v3, you must grant privileges to $MYSQL_USER for each database.

$ mysql -u root
$ source all.sql

Grant all privileges on <dbname> to <your_v2_username>@localhost, then flush privileges.

Remove the dump directory from the pod:

$ cd ../; rm -rf /var/lib/mysql/data/mysqldumpdir

Back up the v2 PostgreSQL database from the gear:

$ rhc ssh -a <v2-application_name>
$ mkdir ~/app-root/data/tmp
$ pg_dump <database_name> | gzip > ~/app-root/data/tmp/<database_name>.gz

Extract the backup file back to your local machine:

$ rhc scp -a <v2_application_name> download <local_dest> app-root/data/tmp/<db-name>.gz
$ gzip -d <database-name>.gz

Create the PostgreSQL service using the v2 application database name, user name and password to create the new service:

$ oc new-app postgresql-persistent -p POSTGRESQL_DATABASE=dbname -p
POSTGRESQL_PASSWORD=password -p POSTGRESQL_USER=username

Check to see if the pod is ready to use:

$ oc get pods

When the pod is up and running, sync the backup directory to pod:

$ oc rsync /local/path/to/dir <postgresql_pod_name>:/var/lib/pgsql/data

Remotely access the pod:

$ oc rsh <pod_name>

Restore the database:

psql dbname < /var/lib/pgsql/data/<database_backup_file>

Remove all backup files that are no longer needed:

$ rm /var/lib/pgsql/data/<database-backup-file>

Remotely access the v2 application via the ssh command:

$ rhc ssh <v2_application_name>

Run mongodump, specifying a single database with -d <database_name> -c <collections>. Without those options, dump all databases. Each database is dumped in its own directory:

$ mongodump -h $OPENSHIFT_MONGODB_DB_HOST -o app-root/repo/mydbdump -u 'admin' -p $OPENSHIFT_MONGODB_DB_PASSWORD
$ cd app-root/repo/mydbdump/<database_name>; tar -cvzf dbname.tar.gz
$ exit

Download dbdump to a local machine in the mongodump directory:

$ mkdir mongodump
$ rhc scp -a <v2 appname> download mongodump \
  app-root/repo/mydbdump/<dbname>/dbname.tar.gz

Start a MongoDB pod in v3. Because the latest image (3.2.6) does not include mongo-tools, to use mongorestore or mongoimport commands you need to edit the default mongodb-persistent template to specify the image tag that contains the mongo-tools, “mongodb:2.4”. For that reason, the following oc export command and edit are necessary:

$ oc export template mongodb-persistent -n openshift -o json > mongodb-24persistent.json

Edit L80 of mongodb-24persistent.json; replace mongodb:latest with mongodb:2.4.

$ oc new-app --template=mongodb-persistent -n <project-name-that-template-was-created-in> \
  MONGODB_USER=user_from_v2_app -p \
  MONGODB_PASSWORD=password_from_v2_db -p \
  MONGODB_DATABASE=v2_dbname -p \
  MONGODB_ADMIN_PASSWORD=password_from_v2_db
$ oc get pods

When the mongodb pod is up and running, copy the database archive files to the v3 MongoDB pod:

$ oc rsync local/path/to/mongodump <mongodb_pod_name>:/var/lib/mongodb/data
$ oc rsh <mongodb_pod>

In the MongoDB pod, complete the following for each database you want to restore:

$ cd /var/lib/mongodb/data/mongodump
$ tar -xzvf dbname.tar.gz
$ mongorestore -u $MONGODB_USER -p $MONGODB_PASSWORD -d dbname -v /var/lib/mongodb/data/mongodump

Check if the database is restored:

$ mongo admin -u $MONGODB_USER -p $MONGODB_ADMIN_PASSWORD
$ use dbname
$ show collections
$ exit

Remove the mongodump directory from the pod:

$ rm -rf /var/lib/mongodb/data/mongodump

Set up a new GitHub repository and add it as a remote branch to the current, local v2 Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>.git

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Ensure that all important files such as setup.py, wsgi.py, requirements.txt, and etc are pushed to new repository.

Use the oc command to launch a new Python application from the builder image and source code:

$ oc new-app --strategy=source
python:3.3~https://github.com/<github-id>/<repo-name> --name=<app-name> -e
<ENV_VAR_NAME>=<env_var_value>

Set up a new GitHub repository and add it as a remote branch to the current, local v2 Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>.git

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

If you do not have a Gemfile and are running a simple rack application, copy this Gemfile into the root of your source:

https://github.com/openshift/ruby-ex/blob/master/Gemfile

Use the oc command to launch a new Ruby application from the builder image and source code:

$ oc new-app --strategy=source
ruby:2.0~https://github.com/<github-id>/<repo-name>.git

Set up a new GitHub repository and add it as a remote branch to the current, local v2 Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Use the oc command to launch a new PHP application from the builder image and source code:

$ oc new-app https://github.com/<github-id>/<repo-name>.git
--name=<app-name> -e <ENV_VAR_NAME>=<env_var_value>

Set up a new GitHub repository and add it as a remote branch to the current, local v2 Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Edit the local Git repository and push changes upstream to make it v3 compatible:

Set up a new GitHub repository and add it as a remote branch to the current, local Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Edit the local Git repository and push changes upstream to make it v3 compatible:

Use the oc command to launch a new Node.js application from the builder image and source code:

$ oc new-app https://github.com/<github-id>/<repo-name>.git
--name=<app-name> -e <ENV_VAR_NAME>=<env_var_value>

Set up a new GitHub repository and add it as a remote branch to the current, local Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Create the new application using the JBoss EAP 6 builder image (jboss-eap64-openshift) and the source code repository from GitHub:

$ oc new-app --strategy=source jboss-eap64-openshift~https://github.com/<github-id>/<repo-name>.git

Set up a new GitHub repository and add it as a remote branch to the current, local Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Create the new application using the JBoss Web Server 3 (Tomcat 7) builder image (jboss-webserver30-tomcat7) and the source code repository from GitHub:

$ oc new-app --strategy=source
jboss-webserver30-tomcat7-openshift~https://github.com/<github-id>/<repo-name>.git
--name=<app-name> -e <ENV_VAR_NAME>=<env_var_value>

Set up a new GitHub repository and add it as a remote branch to the current, local Git repository:

$ git remote add <remote-name> https://github.com/<github-id>/<repo-name>

Push the local v2 source code to the new repository:

$ git push -u <remote-name> master

Edit the local Git repository and push the changes upstream to make it v3 compatible:

Use the the oc command to launch a new Wildfly application from the builder image and source code:

$ oc new-app https://github.com/<github-id>/<repo-name>.git
 --image-stream=”openshift/wildfly:10.0" --name=<app-name> -e
 <ENV_VAR_NAME>=<env_var_value>

Clone a quickstart template and add your GitHub repository as a remote:

$ git clone <one-of-the-template-URLs-listed-above>
$ cd <your local git repository>
$ git remote add upstream <https://github.com/<git-id>/<quickstart-repo>.git>
$ git push -u upstream master

Commit and push your source code to GitHub:

$ cd <your local repository>
$ git commit -am “added code for my app”
$ git push origin master

Create a new application in v3:

$ oc new-app --template=<template> \
-p SOURCE_REPOSITORY_URL=<https://github.com/<git-id>/<quickstart_repo>.git> \
-p DATABASE_USER=<your_db_user> \
-p DATABASE_NAME=<your_db_name> \
-p DATABASE_PASSWORD=<your_db_password> \
-p DATABASE_ADMIN_PASSWORD=<your_db_admin_password> 1

You should now have 2 pods running, a web framework pod, and a database pod. The web framework pod environment should match the database pod environment. You can list the environment variables with oc set env pod/<pod_name> --list:

After creating a BuildConfig` from a GitHub repository, run:

$ oc describe bc/<name-of-your-BuildConfig>

This will output a webhook GitHub URL that looks like:

<https://api.dev-preview-int.openshift.com:443/oapi/v1/namespaces/nsname/buildconfigs/bcname/webhooks/secret/github>.

S2I can build images from source code in a local file system or from a Git repository. To build a new container image from the builder image and the source code:

$ s2i build <source-location> <builder-image-name> <output-image-name>

Test the built image with the Docker daemon:

$ docker run -d --name <new-name> -p <port-number>:<port-number> <output-image-name>
$ curl localhost:<port-number>

Create a new application from the image in the OpenShift registry using the oc command:

$ oc new-app <image-name>