API reference

set envs

  • path: /apps/{app}/env
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Envs updated
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

app log

  • path: /apps/{app}/log
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

app unlock

  • path: /apps/{app}/lock
  • produce: application/json
  • method: DELETE
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

app swap

  • path: /swap
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 401: Unauthorized
  • 404: App not found
  • 200: Ok
  • 409: App locked
  • 412: Number of units or platform don’t match

app start

  • path: /apps/{app}/start
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

revoke access to app

  • path: /apps/{app}/teams/{team}
  • method: DELETE
  • 200: Access revoked
  • 401: Unauthorized
  • 403: Forbidden
  • 404: App or team not found

app restart

  • path: /apps/{app}/restart
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

register unit

  • path: /apps/{app}/units/register
  • produce: application/json
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

metric envs

  • path: /apps/{app}/metric/envs
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

remove app

  • path: /apps/{name}
  • produce: application/x-json-stream
  • method: DELETE
  • 200: App removed
  • 401: Unauthorized
  • 404: Not found

grant access to app

  • path: /apps/{app}/teams/{team}
  • method: PUT
  • 200: Access granted
  • 401: Unauthorized
  • 404: App or team not found
  • 409: Grant already exists

app log

  • path: /apps/{app}/log
  • produce: application/x-json-stream
  • method: GET
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

bind service instance

  • path: /services/{service}/instances/{instance}/{app}
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

unset envs

  • path: /apps/{app}/env
  • produce: application/x-json-stream
  • method: DELETE
  • 200: Envs removed
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

set cname

  • path: /apps/{app}/cname
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

app stop

  • path: /apps/{app}/stop
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

rebuild routes

  • path: /apps/{app}/routes
  • produce: application/json
  • method: POST
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

app update

  • path: /apps/{name}
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: App updated
  • 401: Unauthorized
  • 404: Not found

add units

  • path: /apps/{name}/units
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Units added
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

set node status

  • path: /node/status
  • produce: application/json
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: App or unit not found
  • 401: Unauthorized

get envs

  • path: /apps/{app}/env
  • produce: application/x-json-stream
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: App not found

app info

  • path: /apps/{name}
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Not found

app create

  • path: /apps
  • produce: application/json
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: App created
  • 403: Quota exceeded
  • 401: Unauthorized
  • 409: App already exists

app list

  • path: /apps
  • produce: application/json
  • method: GET
  • 200: List apps
  • 401: Unauthorized
  • 204: No content

unbind service instance

  • path: /services/{service}/instances/{instance}/{app}
  • produce: application/x-json-stream
  • method: DELETE
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

set unit status

  • path: /apps/{app}/units/{unit}
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: App or unit not found
  • 401: Unauthorized

run commands

  • path: /apps/{app}/run
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 401: Unauthorized
  • 404: App not found

app sleep

  • path: /apps/{app}/sleep
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

remove units

  • path: /apps/{name}/units
  • produce: application/x-json-stream
  • method: DELETE
  • 200: Units removed
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

unset cname

  • path: /apps/{app}/cname
  • method: DELETE
  • 200: Ok
  • 400: Invalid data
  • 404: App not found
  • 401: Unauthorized

user create

  • path: /users
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: User created
  • 403: Forbidden
  • 401: Unauthorized
  • 409: User already exists

change password

  • path: /users/password
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Ok
  • 400: Invalid data
  • 403: Forbidden
  • 404: Not found
  • 401: Unauthorized

remove team

  • path: /teams/{name}
  • method: DELETE
  • 200: Team removed
  • 401: Unauthorized
  • 403: Forbidden
  • 404: Not found

user list

  • path: /users
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized

user info

  • path: /users/info
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized

add key

  • path: /users/keys
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 401: Unauthorized
  • 409: Key already exists

remove key

  • path: /users/keys/{key}
  • method: DELETE
  • 200: Ok
  • 400: Invalid data
  • 404: Not found
  • 401: Unauthorized

remove user

  • path: /users
  • method: DELETE
  • 200: User removed
  • 401: Unauthorized
  • 404: Not found

logout

  • path: /users/tokens
  • method: DELETE
  • 200: Ok

team list

  • path: /teams
  • produce: application/json
  • method: GET
  • 200: List teams
  • 401: Unauthorized
  • 204: No content

list keys

  • path: /users/keys
  • produce: application/json
  • method: GET
  • 200: OK
  • 400: Invalid data
  • 401: Unauthorized

regenerate token

  • path: /users/api-key
  • produce: application/json
  • method: POST
  • 200: OK
  • 401: Unauthorized
  • 404: User not found

show token

  • path: /users/api-key
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: User not found

login

  • path: /auth/login
  • produce: application/json
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 403: Forbidden
  • 404: Not found
  • 401: Unauthorized

reset password

  • path: /users/{email}/password
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 403: Forbidden
  • 404: Not found
  • 401: Unauthorized

team create

  • path: /teams
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Team created
  • 401: Unauthorized
  • 409: Team already exists

get auth scheme

  • path: /auth/scheme
  • produce: application/json
  • method: GET
  • 200: OK

dump goroutines

  • path: /debug/goroutines
  • method: GET
  • 200: Ok

deploy list

  • path: /deploys
  • produce: application/json
  • method: GET
  • 200: OK
  • 204: No content

deploy info

  • path: /deploys/{deploy}
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Not found

app deploy

  • path: /apps/{appname}/deploy
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: OK
  • 400: Invalid data
  • 403: Forbidden
  • 404: Not found

deploy diff

  • path: /apps/{appname}/diff
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: OK
  • 400: Invalid data
  • 403: Forbidden
  • 404: Not found

rollback

  • path: /apps/{appname}/deploy/rollback
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: OK
  • 400: Invalid data
  • 403: Forbidden
  • 404: Not found

healthcheck

  • path: /healthcheck
  • method: GET
  • 200: OK
  • 500: Internal server error

template destroy

  • path: /iaas/templates/{template_name}
  • method: DELETE
  • 200: OK
  • 401: Unauthorized
  • 404: Not found

template update

  • path: /iaas/templates/{template_name}
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: OK
  • 400: Invalid data
  • 404: Not found
  • 401: Unauthorized

machine list

  • path: /iaas/machines
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized

machine destroy

  • path: /iaas/machines/{machine_id}
  • method: DELETE
  • 200: OK
  • 400: Invalid data
  • 404: Not found
  • 401: Unauthorized

machine template list

  • path: /iaas/templates
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized

template create

  • path: /iaas/templates
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Template created
  • 401: Unauthorized

index

  • path: /
  • method: GET
  • 200: OK

api info

  • path: /info
  • produce: application/json
  • method: GET
  • 200: OK

dissociate role from user

  • path: /roles/{name}/user/{email}
  • method: DELETE
  • 200: Ok
  • 400: Invalid data
  • 404: Role not found
  • 401: Unauthorized

list permissions

  • path: /permissions
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized

remove default role

  • path: /role/default
  • method: DELETE
  • 200: Ok
  • 400: Invalid data
  • 401: Unauthorized

list default roles

  • path: /role/default
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized

role create

  • path: /roles
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Role created
  • 401: Unauthorized
  • 409: Role already exists

remove role

  • path: /roles/{name}
  • method: DELETE
  • 200: Role removed
  • 401: Unauthorized
  • 404: Role not found

role list

  • path: /roles
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized

add permissions

  • path: /roles/{name}/permissions
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 401: Unauthorized
  • 409: Permission not allowed

assign role to user

  • path: /roles/{name}/user
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: Role not found
  • 401: Unauthorized

role info

  • path: /roles/{name}
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Role not found

add default role

  • path: /role/default
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 401: Unauthorized

remove permission

  • path: /roles/{name}/permissions/{permission}
  • method: DELETE
  • 200: Permission removed
  • 401: Unauthorized
  • 404: Not found

plan create

  • path: /plans
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Plan created
  • 401: Unauthorized
  • 409: Plan already exists

plan list

  • path: /plans
  • produce: application/json
  • method: GET
  • 200: OK
  • 204: No content

remove plan

  • path: /plans/{name}
  • method: DELETE
  • 200: Plan removed
  • 401: Unauthorized
  • 404: Plan not found

router list

  • path: /plans/routers
  • produce: application/json
  • method: GET
  • 200: OK
  • 204: No content

add platform

  • path: /platforms
  • produce: application/x-json-stream
  • consume: multipart/form-data
  • method: POST
  • 200: Platform created
  • 400: Invalid data
  • 401: Unauthorized

update platform

  • path: /platforms/{name}
  • produce: application/x-json-stream
  • method: PUT
  • 200: Platform updated
  • 401: Unauthorized
  • 404: Not found

remove platform

  • path: /platforms/{name}
  • method: DELETE
  • 200: Platform removed
  • 401: Unauthorized
  • 404: Not found

platform list

  • path: /platforms
  • produce: application/json
  • method: GET
  • 200: List platforms
  • 401: Unauthorized
  • 204: No content

pool list

  • path: /pools
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: User not found
  • 204: No content

pool create

  • path: /pools
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Pool created
  • 401: Unauthorized
  • 409: Pool already exists

remove pool

  • path: /pools/{name}
  • method: DELETE
  • 200: Pool removed
  • 401: Unauthorized
  • 404: Pool not found

add team too pool

  • path: /pools/{name}/team
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Pool updated
  • 401: Unauthorized
  • 400: Invalid data
  • 404: Pool not found

remove team from pool

  • path: /pools/{name}/team
  • method: DELETE
  • 200: Pool updated
  • 401: Unauthorized
  • 400: Invalid data
  • 404: Pool not found

pool update

  • path: /pools/{name}
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Pool updated
  • 401: Unauthorized
  • 404: Pool not found
  • 409: Default pool already defined

profile index handler

  • path: /debug/pprof
  • method: GET
  • 200: Ok
  • 401: Unauthorized

profile cmdline handler

  • path: /debug/pprof/cmdline
  • method: GET
  • 200: Ok
  • 401: Unauthorized

profile handler

  • path: /debug/pprof/profile
  • method: GET
  • 200: Ok
  • 401: Unauthorized

profile symbol handler

  • path: /debug/pprof/symbol
  • method: GET
  • 200: Ok
  • 401: Unauthorized

user quota

  • path: /users/{email}/quota
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: User not found

update user quota

  • path: /users/{email}/quota
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Quota updated
  • 400: Invalid data
  • 404: User not found
  • 401: Unauthorized

application quota

  • path: /apps/{appname}/quota
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Application not found

update application quota

  • path: /apps/{appname}/quota
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Quota updated
  • 400: Invalid data
  • 404: Application not found
  • 401: Unauthorized

saml callback

  • path: /auth/saml
  • method: POST
  • 200: Ok
  • 400: Invalid data

saml metadata

  • path: /auth/saml
  • produce: application/xml
  • method: GET
  • 200: Ok
  • 400: Invalid data

service instance list

  • path: /services/instances
  • produce: application/json
  • method: GET
  • 200: List services instances
  • 401: Unauthorized
  • 204: No content

service instance status

  • path: /services/{service}/instances/{instance}/status
  • method: GET
  • 200: List services instances
  • 401: Unauthorized
  • 404: Service instance not found

service instance proxy

  • path: /services/{service}/proxy/{instance}
  • method: *
  • 401: Unauthorized
  • 404: Instance not found

grant access to service instance

  • path: /services/{service}/instances/permission/{instance}/{team}
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Access granted
  • 401: Unauthorized
  • 404: Service instance not found

remove service instance

  • path: /services/{name}/instances/{instance}
  • produce: application/x-json-stream
  • method: DELETE
  • 200: Service removed
  • 401: Unauthorized
  • 404: Service instance not found

service instance info

  • path: /services/{service}/instances/{instance}
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Service instance not found

service info

  • path: /services/{name}
  • produce: application/json
  • method: GET
  • 200: OK

service doc

  • path: /services/{name}/doc
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Not found

service instance create

  • path: /services/{service}/instances
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Service created
  • 401: Unauthorized
  • 409: Service already exists

service instance update

  • path: /services/{service}/instances/{instance}
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Service instance updated
  • 400: Invalid data
  • 404: Service instance not found
  • 401: Unauthorized

service plans

  • path: /services/{name}/plans
  • produce: application/json
  • method: GET
  • 200: OK
  • 401: Unauthorized
  • 404: Service not found

revoke access to service instance

  • path: /services/{service}/instances/permission/{instance}/{team}
  • method: DELETE
  • 200: Access revoked
  • 401: Unauthorized
  • 404: Service instance not found

revoke access to a service

  • path: /services/{service}/team/{team}
  • method: DELETE
  • 200: Access revoked
  • 400: Team not found
  • 404: Service not found
  • 401: Unauthorized
  • 409: Team does not has access to this service

change service documentation

  • path: /services/{name}/doc
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Documentation updated
  • 401: Unauthorized
  • 403: Forbidden (team is not the owner or service with instances)

service list

  • path: /services
  • produce: application/json
  • method: GET
  • 200: List services
  • 401: Unauthorized
  • 204: No content

grant access to a service

  • path: /services/{service}/team/{team}
  • method: PUT
  • 200: Service updated
  • 400: Team not found
  • 404: Service not found
  • 401: Unauthorized
  • 409: Team already has access to this service

service update

  • path: /services/{name}
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Service updated
  • 400: Invalid data
  • 403: Forbidden (team is not the owner)
  • 404: Service not found
  • 401: Unauthorized

service delete

  • path: /services/{name}
  • method: DELETE
  • 200: Service removed
  • 401: Unauthorized
  • 403: Forbidden (team is not the owner or service with instances)
  • 404: Service not found

service proxy

  • path: /services/proxy/service/{service}
  • method: *
  • 401: Unauthorized
  • 404: Service not found

service create

  • path: /services
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 400: Invalid data
  • 201: Service created
  • 401: Unauthorized
  • 409: Service already exists

node container upgrade

  • path: /docker/nodecontainers/{name}/upgrade
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invald data
  • 404: Not found
  • 401: Unauthorized

get autoscale config

  • path: /docker/autoscale/config
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized

autoscale rules list

  • path: /docker/autoscale/rules
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized
  • 204: No content

update nodes

  • path: /docker/node
  • consume: application/x-www-form-urlencoded
  • method: PUT
  • 200: Ok
  • 400: Invalid data
  • 404: Not found
  • 401: Unauthorized

list healing history

  • path: /docker/healing
  • produce: application/json
  • method: GET
  • 200: Ok
  • 400: Invalid data
  • 204: No content
  • 401: Unauthorized

logs config

  • path: /docker/logs
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized

node container create

  • path: /docker/nodecontainers
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invald data
  • 401: Unauthorized

node container info

  • path: /docker/nodecontainers/{name}
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized
  • 404: Not found

delete autoscale rule

  • path: /docker/autoscale/rules/{id}
  • method: DELETE
  • 200: Ok
  • 401: Unauthorized
  • 404: Not found

add node

  • path: /docker/node
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 201: Ok
  • 404: Not found
  • 401: Unauthorized

move containers

  • path: /docker/containers/move
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: Not found
  • 401: Unauthorized

list autoscale history

  • path: /docker/healing
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized
  • 204: No content

logs config set

  • path: /docker/logs
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 401: Unauthorized

list containers by app

  • path: /docker/node/apps/{appname}/containers
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized
  • 404: Not found
  • 204: No content

autoscale run

  • path: /docker/autoscale/run
  • produce: application/x-json-stream
  • method: POST
  • 200: Ok
  • 401: Unauthorized

node healing update

  • path: /docker/healing/node
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 401: Unauthorized

remove node

  • path: /docker/node/{address}
  • method: DELETE
  • 200: Ok
  • 401: Unauthorized
  • 404: Not found

remove node healing

  • path: /docker/healing/node
  • produce: application/json
  • method: DELETE
  • 200: Ok
  • 401: Unauthorized

list nodes

  • path: /docker/node
  • produce: application/json
  • method: GET
  • 200: Ok
  • 204: No content

move container

  • path: /docker/container/{id}/move
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 404: Not found
  • 401: Unauthorized

list containers by node

  • path: /docker/node/{address}/containers
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized
  • 404: Not found
  • 204: No content

node container update

  • path: /docker/nodecontainers/{name}
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invald data
  • 404: Not found
  • 401: Unauthorized

autoscale set rule

  • path: /docker/autoscale/rules
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 401: Unauthorized

node healing info

  • path: /docker/healing/node
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized

remove node container list

  • path: /docker/nodecontainers
  • produce: application/json
  • method: GET
  • 200: Ok
  • 401: Unauthorized

rebalance containers

  • path: /docker/containers/rebalance
  • produce: application/x-json-stream
  • consume: application/x-www-form-urlencoded
  • method: POST
  • 200: Ok
  • 400: Invalid data
  • 204: No content
  • 401: Unauthorized

remove node container

  • path: /docker/nodecontainers/{name}
  • method: DELETE
  • 200: Ok
  • 401: Unauthorized
  • 404: Not found