sept0r/parse-server

•Updated over 10 years ago

Short description is empty for this repo.

Image

404

sept0r/parse-server repository overview

⁠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:

Parse Server Diagram

Features:

Support latest parse-server npm version: yongjhih/parse-server:latest
Support various parse-server npm versions: yongjhih/parse-server:2.2.0
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:

parse-server pulls

⁠Getting Started

Parse Dashboard Screenshot

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

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

# 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={appId}         \
             -e MASTER_KEY={masterKey} \
             -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:

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

$ 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: {appId}" \
  -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={mongodb://mongodb.intra:27017/dev} \
             -e APP_ID={appId}                                   \
             -e MASTER_KEY={masterKey}                           \
             -p 1337:1337                                        \
             -p 2022:22                                          \
             --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 {/home/yongjhih/parse/cloud}:/parse/cloud        \
             -e DATABASE_URI={mongodb://mongodb.intra:27017/dev} \
             -e APP_ID={appId}                                   \
             -e MASTER_KEY={masterKey}                           \
             -p 1337:1337                                        \
             -p 2022:22                                          \
             --link mongo                                        \
             --name parse-server                                 \
             yongjhih/parse-server

With volume container:

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

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

⁠Usage of specific parse-server version

Specify parse-server:2.2.0:

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

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={appId}         \
             -e MASTER_KEY={masterKey} \
             -p 1337:1337              \
             -p 2022:22                \
             --link mongo              \
             --name parse-server       \
             yongjhih/parse-server:dev

⁠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 -p 2022:22 --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-server 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

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.

⁠See Also

Tag summary

Recent tags

Content type

Image

Digest

Size

264.4 MB

Last updated

over 10 years ago

docker pull sept0r/parse-server