docker-parse-server

You should not build your parse-server image instead of reuse this yongjhih/parse-server image, then plugin your parse-cloud-code container (allow dynamic update) and mongodb container.

Welcome PR.

Here is overview:

Features:

Support latest parse-server npm version: yongjhih/parse-server:latest
Support various parse-server npm versions: yongjhih/parse-server:2.2.7
Support latest parse-server commit: yongjhih/parse-server:dev
Support docker stack with docker-compose
Support parse-cloud-code volume
Support parse-dashboard
Support mongodb
Support git deploy parse-cloud-code and auto effect after pushed
Tested docker image

Most pulled:

Getting Started

$ docker run -d -p 27017:27017 --name mongo mongo

$ docker run -d                                \
             -e APP_ID=${APP_ID}         \
             -e MASTER_KEY=${MASTER_KEY} \
             -p 1337:1337                      \
             --link mongo                      \
             --name parse-server               \
             yongjhih/parse-server

$ docker run -d                                \
             -p 2022:22                        \
             --volumes-from parse-server       \
             --name parse-cloud-code-git       \
             yongjhih/parse-server:git

# Test parse-server
$ curl -X POST \
  -H "X-Parse-Application-Id: {appId}" \
  -H "Content-Type: application/json" \
  -d '{}' \
  http://localhost:1337/parse/functions/hello

$ docker run -d \
             -e APP_ID=${APP_ID}         \
             -e MASTER_KEY=${MASTER_KEY} \
             -e SERVER_URL=http://localhost:1337/parse \
             -p 4040:4040                      \
             --link parse-server               \
             --name parse-dashboard            \
             yongjhih/parse-dashboard

# The above command will asuume you will later create a ssh 
# and log into the dashboard remotely in production. 
#  However, to see the dashboard instanly using either
#  localhost:4040 or someip:4040(if hosted somewhere remotely)
# then you need to add extra option to allowInsecureHTTP like
# It is also required that you create username and password 
# before accessing the portal else you cant get in

$  docker run -d \
             -e APP_ID=$(APP_ID)\
             -e MASTER_KEY=$(MASTER_KEY)\
             -e SERVER_URL=http://localhost:1337/parse \
             -e PARSE_DASHBOARD_ALLOW_INSECURE_HTTP=1  \
             -e USER1=yourUsername  \
             -e USER1_PASSWORD=yourUsernamesPassword \
             -p 4040:4040                      \
             --link parse-server               \
             --name parse-dashboard            \
             yongjhih/parse-dashboard

or with docker-compose:

$ wget https://github.com/yongjhih/docker-parse-server/raw/master/docker-compose.yml
$ APP_ID=myAppId MASTER_KEY=myMasterKey docker-compose up -d

p.s. $ wget https://github.com/yongjhih/docker-parse-server/raw/master/docker-compose.yml -O - | APP_ID=myAppId MASTER_KEY=myMasterKey docker-compose up -d -f - # not supported for docker-compose container

Deploy parse-cloud-code via git:

# This command wil create a SSH keys for you as
#  ~/.ssh/id_rsa.pub and another private key.
# you can leave the options balnk by pressing enter.

$ ssh-keygen -t rsa

# If git container name is `parse-cloud-code-git`
$ docker exec -i parse-cloud-code-git ssh-add-key < ~/.ssh/id_rsa.pub

# port 2022, repo path is `/parse-cloud-code`
$ git clone ssh://git@localhost:2022/parse-cloud-code
$ cd parse-cloud-code
$ echo "Parse.Cloud.define('hello', function(req, res) { res.success('Hi, git'); });" > main.js
$ git add main.js && git commit -m 'Update main.js'
$ git push origin master

$ curl -X POST \
  -H "X-Parse-Application-Id: ${APP_ID}" \
  -H "Content-Type: application/json" \
  -d '{}' \
  http://localhost:1337/parse/functions/hello

api: localhost:1337
git: localhost:2022
mongodb: localhost:27017

Usage of already mongodb with DATABASE_URI

$ docker run -d \
             -e DATABASE_URI=${DATABASE_URI:-mongodb://mongodb.intra:27017/dev} \
             -e APP_ID=${APP_ID}                            \
             -e MASTER_KEY=${MASTER_KEY}                    \
             -p 1337:1337                                        \
             --name parse-server                                 \
             yongjhih/parse-server

or with docker-compose:

$ wget https://github.com/yongjhih/docker-parse-server/raw/master/docker-compose.yml
$ DATABASE_URI={mongodb://mongodb.intra:27017/dev} APP_ID={appId} MASTER_KEY={masterKey} docker-compose up

Usage of already parse-cloud-code

With host folder:

$ docker run -d \
             -v ${PARSE_CLOUD:-/home/yongjhih/parse/cloud}:/parse/cloud \
             -e DATABASE_URI=${PARSE_DATABASE_URI:-mongodb://mongodb.intra:27017/dev} \
             -e APP_ID={appId}         \
             -e MASTER_KEY={masterKey} \
             -p 1337:1337              \
             --link mongo              \
             --name parse-server       \
             yongjhih/parse-server

With volume container:

$ docker create --name parse-cloud-code \
                -v /parse/cloud         \
                ${DOCKER_PARSE_CLOUD:-yongjhih/parse-cloud-code} echo ls /parse/cloud

$ docker run -d \
             --volumes-from parse-cloud-code \
             -e DATABASE_URI=${DATABASE_URI:-mongodb://mongodb.intra:27017/dev} \
             -e APP_ID=${APP_ID}        \
             -e MASTER_KEY=${MASTER_KEY} \
             -p 1337:1337                     \
             --link mongo                     \
             --name parse-server              \
             yongjhih/parse-server

Usage of specific parse-server version

Specify parse-server:2.2.7:

$ docker run -d                                \
             -e APP_ID=${APP_ID}         \
             -e MASTER_KEY=${MASTER_KEY} \
             -p 1337:1337                      \
             --link mongo                      \
             --name parse-server               \
             yongjhih/parse-server:2.2.7

ref. https://github.com/ParsePlatform/parse-server/releases ref. https://www.npmjs.com/package/parse-server

Usage of specific latest commit of ParsePlatform/parse-server of image

$ docker run -d                                \
             -e APP_ID=${APP_ID}         \
             -e MASTER_KEY=${MASTER_KEY} \
             -p 1337:1337                      \
             --link mongo                      \
             --name parse-server               \
             yongjhih/parse-server:dev

Usage of standalone parse dashboard

Start up parse-dashboard: https://github.com/yongjhih/docker-parse-dashboard

And, start up other containers without parse-dashboard:

$ APP_ID=myAppId MASTER_KEY=myMasterKey docker-compose -f docker-compose-without-dashboard.yml up -d

Usage of https certificated domain with letsencrypt

$ git clone https://github.com/yongjhih/docker-parse-server
$ cd docker-parse-server

$ USER1=yongjhih \
  USER1_PASSWORD=yongjhih \
  PARSE_DASHBOARD_VIRTUAL_HOST=parse.example.com \
  PARSE_DASHBOARD_LETSENCRYPT_HOST=parse.example.com \
  PARSE_DASHBOARD_LETSENCRYPT_EMAIL=yongjhih@example.com \
  PARSE_SERVER_VIRTUAL_HOST=api.example.com \
  PARSE_SERVER_LETSENCRYPT_HOST=api.example.com \
  PARSE_SERVER_LETSENCRYPT_EMAIL=yongjhih@example.com \
  SERVER_URL=https://api.example.com/parse \
  APP_ID=myAppId MASTER_KEY=myMasterKey docker-compose -f docker-compose-le.yml up

Open your https://parse.example.com/ url and unblock browser protected scripts, that's it.

BTW, you can remove unused 80 port after volumes/proxy/certs generated:

sed -i -- '/- "80:80"/d' docker-compose-le.yml

Usage of push notification

$ mkdir volumes/certs
$ cp /path/your/Certificated.p12 volumes/certs/dev-pfx
$ cp /path/your/cert.pem volumes/certs/dev-pfx-cert.pem
$ cp /path/your/key.pem volumes/certs/dev-pfx-key.pem
$ docker-compose up

Integration of parse-cloud-code image on GitHub and DockerHub

Fork https://github.com/yongjhih/parse-cloud-code
Add your cloud code into https://github.com/{username}/parse-cloud-code/tree/master/cloud
Create an automated build image on DockerHub for forked {username}/parse-cloud-code repository
docker pull {username}/parse-cloud-code

Without docker-compose:

Re/create parse-cloud-code volume container: docker create -v /parse/code --name parse-cloud-code {username}/parse-cloud-code /bin/true
Re/create parse-server container with volume: docker run -d --volumes-from parse-cloud-code APP_ID={appId} -e MASTER_KEY={masterKey} -p 1337:1337 --link mongo yongjhih/parse-server

With docker-compose.yml:

# ...
parse-cloud-code:
  # ...
  image: {username}/parse-cloud-code # Specify your parse-cloud-code image
# ...

docker-compose up

Configuration with docker

Specify application ID: -e APP_ID={appId}
Specify master key: -e MASTER_KEY={masterKey}
Specify database uri: -e DATABASE_URI={mongodb://mongodb.intra:27017/dev}
Specify parse-server port on host: -p {1338}:1337
Specify parse-cloud-code git port on host: -p {2023}:22
Specify database port on host: -p {27018}:27017
Specify parse cloud code host folder: -v {/home/yongjhih/parse/cloud}:/parse/cloud
Specify parse cloud code volume container: --volumes-from {parse-cloud-code}
Specify parse-server prefix: -e PARSE_MOUNT={/parse}

Configuration with docker-compose.yml

Environment:

# ...
parse-server:
  # ...
  environment:
    DATABASE_URI: $DATABASE_URI
    APP_ID: $APP_ID
    MASTER_KEY: $MASTER_KEY
    PARSE_MOUNT: $PARSE_MOUNT # /parse
    COLLECTION_PREFIX: $COLLECTION_PREFIX
    CLIENT_KEY: $CLIENT_KEY
    REST_API_KEY: $REST_API_KEY
    DOTNET_KEY: $DOTNET_KEY
    JAVASCRIPT_KEY: $JAVASCRIPT_KEY
    DOTNET_KEY: $DOTNET_KEY
    FILE_KEY: $FILE_KEY
    FACEBOOK_APP_IDS: $FACEBOOK_APP_IDS
    SERVER_URL: $SERVER_URL
    MAX_UPLOAD_SIZE: $MAX_UPLOAD_SIZE # 20mb
    GCM_ID: $GCM_ID
    GCM_KEY: $GCM_KEY
    PRODUCTION_PFX: $PRODUCTION_PFX
    PRODUCTION_BUNDLE_ID: $PRODUCTION_BUNDLE_ID
    PRODUCTION_CERT: $PRODUCTION_CERT # prodCert.pem
    PRODUCTION_KEY: $PRODUCTION_KEY # prodKey.pem
    DEV_PFX: $DEV_PFX
    DEV_BUNDLE_ID: $DEV_BUNDLE_ID
    DEV_CERT: $DEV_CERT # devCert.pem
    DEV_KEY: $DEV_KEY # devKey.pem
    VERIFY_USER_EMAILS: $VERIFY_USER_EMAILS # false
    ENABLE_ANON_USERS: $ENABLE_ANON_USERS # true
    ALLOW_CLIENT_CLASS_CREATION: $ALLOW_CLIENT_CLASS_CREATION # true
    APP_NAME: $APP_NAME
    PUBLIC_SERVER_URL: $PUBLIC_SERVER_URL
    TRUST_PROXY: $TRUST_PROXY # false
# ...

Remote parse-cloud-code image:

# ...
parse-cloud-code:
  # ...
  image: yongjhih/parse-cloud-code # Specify your parse-cloud-code image
# ...

or host folder:

# ...
parse-cloud-code:
  # ...
  image: yongjhih/parse-server
  volumes:
    - /home/yongjhih/parse/cloud:/parse/cloud
  # ...
# ...

Add ssh-key for git

$ docker exec -i parse-cloud-cloud-git ssh-add-key < ~/.ssh/id_rsa.pub

Import keys from github:

$ curl https://github.com/yongjhih.keys | docker exec -i parse-server ssh-add-key

Deploy cloud code via git

$ git clone ssh://git@localhost:2022/parse-cloud-code
# ...
$ git push origin master

Getting Started With Cloud Services

Getting Started With Heroku + Mongolab Development

With the Heroku Button

Without It

Clone the repo and change directory to it
Log in with the Heroku Toolbelt and create an app: heroku create
Use the MongoLab addon: heroku addons:create mongolab:sandbox
By default it will use a path of /parse for the API routes. To change this, or use older client SDKs, run heroku config:set PARSE_MOUNT=/1
Deploy it with: git push heroku master

Getting Started With AWS Elastic Beanstalk

With the Deploy to AWS Button

Without It

Clone the repo and change directory to it
Log in with the AWS Elastic Beanstalk CLI, select a region, and create an app: eb init
Create an environment and pass in MongoDB URI, App ID, and Master Key: eb create --envvars DATABASE_URI=<replace with URI>,APP_ID=<replace with Parse app ID>,MASTER_KEY=<replace with Parse master key>

Getting Started With Microsoft Azure App Service

With the Deploy to Azure Button

Without It

A detailed tutorial is available here: Azure welcomes Parse developers

Getting Started With Google App Engine

Clone the repo and change directory to it
Create a project in the Google Cloud Platform Console.
Enable billing for your project.
Install the Google Cloud SDK.
Setup a MongoDB server. You have a few options:
Create a Google Compute Engine virtual machine with MongoDB pre-installed.
Use MongoLab to create a free MongoDB deployment on Google Cloud Platform.
Modify app.yaml to update your environment variables.
Delete Dockerfile
Deploy it with gcloud preview app deploy

A detailed tutorial is available here: Running Parse server on Google App Engine

Getting Started With Scalingo

With the Scalingo button

Without it

Clone the repo and change directory to it
Log in with the Scalingo CLI and create an app: scalingo create my-parse
Use the Scalingo MongoDB addon: scalingo addons-add scalingo-mongodb free
Setup MongoDB connection string: scalingo env-set DATABASE_URI='$SCALINGO_MONGO_URL'
By default it will use a path of /parse for the API routes. To change this, or use older client SDKs, run scalingo env-set PARSE_MOUNT=/1
Deploy it with: git push scalingo master

Using it

You can use the REST API, the JavaScript SDK, and any of our open-source SDKs:

Example request to a server running locally:

curl -X POST \
  -H "X-Parse-Application-Id: myAppId" \
  -H "Content-Type: application/json" \
  -d '{"score":1337,"playerName":"Sean Plott","cheatMode":false}' \
  http://localhost:1337/parse/classes/GameScore

curl -X POST \
  -H "X-Parse-Application-Id: myAppId" \
  -H "Content-Type: application/json" \
  -d '{}' \
  http://localhost:1337/parse/functions/hello

curl -H "X-Parse-Application-Id: myAppId" \
     -H "X-Parse-Master-Key: myMasterKey" \
     -H "Content-Type: application/json" \
     http://localhost:1337/parse/serverInfo

Example using it via JavaScript:

Parse.initialize('myAppId','unused');
Parse.serverURL = 'https://whatever.herokuapp.com';
var obj = new Parse.Object('GameScore');
obj.set('score',1337);
obj.save().then(function(obj) {
  console.log(obj.toJSON());
  var query = new Parse.Query('GameScore');
  query.get(obj.id).then(function(objAgain) {
    console.log(objAgain.toJSON());
  }, function(err) {console.log(err); });
}, function(err) { console.log(err); });

Example using it on Android:

//in your application class

Parse.initialize(new Parse.Configuration.Builder(getApplicationContext())
        .applicationId("myAppId")
        .clientKey("myClientKey")
        .server("http://myServerUrl/parse/")   // '/' important after 'parse'
        .build());

  ParseObject testObject = new ParseObject("TestObject");
  testObject.put("foo", "bar");
  testObject.saveInBackground();

You can change the server URL in all of the open-source SDKs, but we're releasing new builds which provide initialization time configuration of this property.

kangjor/docker-parse-server

docker-parse-server

Getting Started

Usage of already mongodb with DATABASE_URI

Usage of already parse-cloud-code

Usage of specific parse-server version

Usage of specific latest commit of ParsePlatform/parse-server of image

Usage of standalone parse dashboard

Usage of https certificated domain with letsencrypt

Usage of push notification

Integration of parse-cloud-code image on GitHub and DockerHub

Configuration with docker

Configuration with docker-compose.yml

Add ssh-key for git

Deploy cloud code via git

Getting Started With Cloud Services

Getting Started With Heroku + Mongolab Development

With the Heroku Button

Without It

Getting Started With AWS Elastic Beanstalk

With the Deploy to AWS Button

Without It

Getting Started With Microsoft Azure App Service

With the Deploy to Azure Button

Without It

Getting Started With Google App Engine

Getting Started With Scalingo

With the Scalingo button

Without it

Using it

See Also