Automatic Updates

Any version of the CLI before version 4.0.0 will no longer automatically update. In order to obtain version 4.0.0 you will have to manually install the CLI. Automatic updates will work again once you have upgraded to 4.0.0 or greater.

Once downloaded, the CLI will attempt to automatically update itself when a new version becomes available. This ensures you are always running a compatible version of the Datica CLI. However you can always check out the latest releases on the releases page.

To ensure your CLI can automatically update itself, be sure to put the binary in a location where you have write access without the need for sudo or escalated privileges.

Supported Platforms

Since version 2.0.0, the following platforms and architectures are supported by the Datica CLI.

OS	Architecture
Darwin (Mac OS X)	64-bit
Linux	64-bit
Windows	64-bit

Global Scope

Datica CLI commands can be run anywhere on your system with two exceptions. The init command expects to be inside of either a git repository or a directory that you intend to be a git repository, as it will set up a git repository if one does not exist. Additionally, the git-remote command is used to manage git remotes and must be run inside of a git repository in order to work.

If you have more than one environment, you must specify which environment to use with the global -E flag.

Let's say you have initialized a code project for two environments (ex. "staging" and "production") named mysandbox and myprod. You have two options to specify which environment to run a command against.

First, you can tell the CLI which environment you want to use with the global option -E or --env. Your command might start like this

datica -E myprod ...

If you don't set the -E flag, then the CLI picks one of your environments and prompts you to continue with this environment. This concept of scope will make it easier for Datica customers with multiple environments to use the CLI!

Bash Autocompletion

One feature we've found helpful on *Nix systems is autocompletion in bash. To enable this feature, head over to the github repo and download the datica_autocomplete file. If you use a Mac, you will need to install bash-completion with brew install bash-completion or source the datica_autocomplete file each time you start up a terminal. Store this file locally in /etc/bash_completion.d/ or (/usr/local/etc/bash_completion.d/ on a Mac). Completion will be available when you restart your terminal. Now type datica and hit tab twice to see the list of available commands. Please note that autocompletion only works one level deep. The CLI will not autocomplete or suggest completions when you type datica db and then hit tab twice. It currently only works when you have just datica typed into your terminal. This is a feature we are looking into expanding in the future.

Note: you may have to add source /etc/bash_completion.d/datica_autocomplete (/usr/local/etc/bash_completion.d/datica_autocomplete) in your ~/.bashrc (~/.bash_profile) file.

Global Options

The following table outlines all global options available in the CLI. Global options are always set after the word datica and before any commands. Rather than setting these each time, you may also set an environment variable with the appropriate value which will automatically be used.

Short Name	Long Name	Description	Environment Variable
	--email	Your Datica email that you login to the Dashboard with	DATICA_EMAIL
-U	--username	[DEPRECATED] Your Datica username that you login to the Dashboard with. Please use --email instead	DATICA_USERNAME
-P	--password	Your Datica password that you login to the Dashboard with	DATICA_PASSWORD
-E	--env	The name of the environment for which this command will be run.	DATICA_ENV

Overview

Usage: datica [OPTIONS] COMMAND [arg...]


Options:
  --email           Datica Email ($DATICA_EMAIL)
  -U, --username    [DEPRECATED] Datica Username (This flag is deprecated. Please use --email instead) ($DATICA_USERNAME)
  -P, --password    Datica Password ($DATICA_PASSWORD)
  -E, --env         The name of the environment in which this command will be run ($DATICA_ENV)
  -v, --version     Show the version and exit

Commands:
  certs          Manage your SSL certificates and domains
  clear          Clear out information in the global settings file to fix a misconfigured CLI.
  console        Open a secure console to a service
  db             Tasks for databases
  deploy         Deploy a Docker image to a container service.
  deploy-keys    Tasks for SSH deploy keys
  images         Operations for working with images
  domain         Print out the temporary domain name of the environment
  environments   Manage environments for which you have access
  files          Tasks for managing service files
  git-remote     Manage git remotes to Datica code services
  init           Get started using the Datica platform
  invites        Manage invitations for your organizations
  jobs           Perform operations on a service's jobs
  keys           Tasks for SSH keys
  logout         Clear the stored user information from your local machine
  logs           Show the logs in your terminal streamed from your logging dashboard
  maintenance    Manage maintenance mode for code services
  metrics        Print service and environment metrics in your local time zone
  rake           Execute a rake task
  redeploy       Redeploy a service without having to do a git push. This will cause downtime for all redeploys (see the resources page for more details).
  releases       Manage releases for code services
  rollback       Rollback a code service to a specific release
  services       Perform operations on an environment's services
  sites          Tasks for updating sites, including hostnames, SSL certificates, and private keys
  ssl            Perform operations on local certificates to verify their validity
  status         Get quick readout of the current status of an environment and all of its services
  support-ids    Print out various IDs related to an environment to be used when contacting Datica support
  update         Checks for available updates and updates the CLI if a new update is available
  users          Manage users who have access to the given organization
  vars           Interaction with environment variables for an environment
  version        Output the version and quit
  whoami         Retrieve your user ID
  worker         Manage a service's workers

Run 'datica COMMAND --help' for more information on a command.

Certs

The certs command gives access to certificate and private key management for public facing services. The certs command cannot be run directly but has subcommands.

Create

Usage: datica certs create NAME ((PUBLIC_KEY_PATH PRIVATE_KEY_PATH [-s] [-r]) | -l) [--down-stream]

Create a new domain with an SSL certificate and private key or create a Let's Encrypt certificate

Arguments:
  NAME=""               The name of this SSL certificate plus private key pair
  PUBLIC_KEY_PATH=""    The path to a public key file in PEM format
  PRIVATE_KEY_PATH=""   The path to an unencrypted private key file in PEM format

Options:
  --down-stream="service_proxy"   The down-stream service the cert belongs to.
  -s, --self-signed=false         Whether or not the given SSL certificate and private key are self signed
  -r, --resolve=true              Whether or not to attempt to automatically resolve incomplete SSL certificate issues
  -l, --lets-encrypt=false        Whether or not this is a Let's Encrypt certificate

certs create allows you to upload an SSL certificate and private key which can be used to secure your public facing code service. Alternatively, you may opt to create a Let's Encrypt certificate. When creating a Let's Encrypt certificate, you only need to provide the certificate name along with the "-l" flag. Let's Encrypt certificates are issued asynchronously and may not be available immediately. Use the certs list command to check on the issuance status. Once issued, Let's Encrypt certificates automatically renew before expiring. Cert creation can be done at any time, even after environment provisioning, but must be done before creating a site. When uploading a custom cert, the CLI will check to ensure the certificate and private key match. If you are using a self signed cert, pass in the -s flag and the hostname check will be skipped. Datica requires that your certificate file include your own certificate, intermediate certificates, and the root certificate in that order. If you only include your certificate, the CLI will attempt to resolve this and fetch intermediate and root certificates for you. It is advised that you create a full chain before running this command as the -r flag is accomplished on a "best effort" basis. Here are a few sample commands

datica -E "" certs create wildcard_mysitecom ~/path/to/cert.pem ~/path/to/priv.key
datica -E "" certs create my.site.com --lets-encrypt

List

Usage: datica certs list [--down-stream]

List all existing domains that have SSL certificate and private key pairs

Options:
  --down-stream="service_proxy"   The down-stream service to list certs for.

certs list lists all of the available certs you have created on your environment. The displayed names are the names that should be used as the CERT_NAME parameter in the sites create command. If any certs are Let's Encrypt certs, the issuance status will also be shown. Here is a sample command

datica -E "" certs list

Rm

Usage: datica certs rm NAME [--down-stream]

Remove an existing domain and its associated SSL certificate and private key pair

Arguments:
  NAME=""      The name of the certificate to remove

Options:
  --down-stream="service_proxy"   The down-stream service the cert belongs to.

certs rm allows you to delete old certificate and private key pairs. Only certs that are not in use by a site can be deleted. Here is a sample command

datica -E "" certs rm mywebsite.com

Update

Usage: datica certs update NAME PUBLIC_KEY_PATH PRIVATE_KEY_PATH [-s] [-r] [--down-stream]

Update the SSL certificate and private key pair for an existing domain

Arguments:
  NAME=""               The name of this SSL certificate and private key pair
  PUBLIC_KEY_PATH=""    The path to a public key file in PEM format
  PRIVATE_KEY_PATH=""   The path to an unencrypted private key file in PEM format

Options:
  --down-stream="service_proxy"   The down-stream service the cert belongs to.
  -s, --self-signed=false         Whether or not the given SSL certificate and private key are self signed
  -r, --resolve=true              Whether or not to attempt to automatically resolve incomplete SSL certificate issues

certs update works nearly identical to the certs create command. All rules regarding self signed certs and certificate resolution from the certs create command apply to the certs update command. Let's Encrypt certs cannot be updated since they are automatically renewed before expiring. This is useful for when your certificates have expired and you need to upload new ones. Update your certs and then redeploy your service_proxy. Here is a sample command

datica -E "" certs update mywebsite.com ~/path/to/new/cert.pem ~/path/to/new/priv.key

Clear

Usage: datica clear [--private-key] [--session] [--environments] [--pods] [--all]

Clear out information in the global settings file to fix a misconfigured CLI.

Options:
  --private-key=false    Clear out the saved private key information
  --session=false        Clear out all session information
  --environments=false   Clear out all your environment data
  --pods=false           Clear out all saved pods
  --all=false            Clear out all settings

clear allows you to manage your global settings file in case your CLI becomes misconfigured. The global settings file is stored in your home directory at ~/.datica. You can clear out all settings or pick and choose which ones need to be removed. After running the clear command, any other CLI command will reset the removed settings to their appropriate values. Here are some sample commands

datica clear --all
datica clear --environments # removes your locally cached environment(s) configuration data
datica clear --session --private-key # removes all session and private key authentication information

Console

Usage: datica console SERVICE_NAME [COMMAND]

Open a secure console to a service

Arguments:
  SERVICE_NAME=""   The name of the service to open up a console for
  COMMAND=""        An optional command to run when the console becomes available

console gives you direct access to your database service or application shell. For example, if you open up a console to a postgres database, you will be given access to a psql prompt. You can also open up a mysql prompt, mongo cli prompt, rails console, django shell, and much more. When accessing a database service, the COMMAND argument is not needed because the appropriate prompt will be given to you. If you are connecting to an application service the COMMAND argument is required. Here are some sample commands

datica -E "" console db01
datica -E "" console app01 "bundle exec rails console"

Db

The db command gives access to backup, import, and export services for databases. The db command can not be run directly but has subcommands.

Backup

Usage: datica db backup DATABASE_NAME [-s]

Create a new backup

Arguments:
  DATABASE_NAME=""   The name of the database service to create a backup for (e.g. 'db01')

Options:
  -s, --skip-poll=false   Whether or not to wait for the backup to finish

db backup creates a new backup for the given database service. The backup is started and unless -s is specified, the CLI will poll every few seconds until it finishes. Regardless of a successful backup or not, the logs for the backup will be printed to the console when the backup is finished. If an error occurs and the logs are not printed, you can use the db logs command to print out historical backup job logs. Here is a sample command

datica -E "" db backup db01

Download

Usage: datica db download DATABASE_NAME BACKUP_ID FILEPATH [-f]

Download a previously created backup

Arguments:
  DATABASE_NAME=""   The name of the database service which was backed up (e.g. 'db01')
  BACKUP_ID=""       The ID of the backup to download (found from "datica backup list")
  FILEPATH=""        The location to save the downloaded backup to. This location must NOT already exist unless -f is specified

Options:
  -f, --force=false   If a file previously exists at "filepath", overwrite it and download the backup

db download downloads a previously created backup to your local hard drive. Be careful using this command as it could download PHI. Be sure that all hard drive encryption and necessary precautions have been taken before performing a download. The ID of the backup is found by first running the db list command. Here is a sample command

datica -E "" db download db01 cd2b4bce-2727-42d1-89e0-027bf3f1a203 ./db.sql

This assumes you are downloading a MySQL or PostgreSQL backup which takes the .sql file format. If you are downloading a mongo backup, the command might look like this

datica -E "" db download db01 cd2b4bce-2727-42d1-89e0-027bf3f1a203 ./db.tar.gz

Export

Usage: datica db export DATABASE_NAME FILEPATH [-f]

Export data from a database

Arguments:
  DATABASE_NAME=""   The name of the database to export data from (e.g. 'db01')
  FILEPATH=""        The location to save the exported data. This location must NOT already exist unless -f is specified

Options:
  -f, --force=false   If a file previously exists at filepath, overwrite it and export data

db export is a simple wrapper around the db backup and db download commands. When you request an export, a backup is created that will be added to the list of backups shown when you perform the db list command. Then that backup is immediately downloaded. Regardless of a successful export or not, the logs for the backup will be printed to the console when the export is finished. If an error occurs and the logs are not printed, you can use the db logs command to print out historical backup job logs. Here is a sample command

datica -E "" db export db01 ./dbexport.sql

This assumes you are exporting a MySQL or PostgreSQL database which takes the .sql file format. If you are exporting a mongo database, the command might look like this

datica -E "" db export db01 ./dbexport.tar.gz

Import

Usage: datica db import DATABASE_NAME FILEPATH [-s][-d [-c]]

Import data into a database

Arguments:
  DATABASE_NAME=""   The name of the database to import data to (e.g. 'db01')
  FILEPATH=""        The location of the file to import to the database

Options:
  -c, --mongo-collection=""   If importing into a mongo service, the name of the collection to import into
  -d, --mongo-database=""     If importing into a mongo service, the name of the database to import into
  -s, --skip-backup=false     Skip backing up database. Useful for large databases, which can have long backup times.

db import allows you to inject new data into your database service. For example, if you wrote a simple SQL file

CREATE TABLE mytable (
id TEXT PRIMARY KEY,
val TEXT
);

INSERT INTO mytable (id, val) values ('1', 'test');

and stored it at ./db.sql you could import this into your database service. When importing data into mongo, you may specify the database and collection to import into using the -d and -c flags respectively. Regardless of a successful import or not, the logs for the import will be printed to the console when the import is finished. Before an import takes place, your database is backed up automatically in case any issues arise. Here is a sample command

datica -E "" db import db01 ./db.sql

List

Usage: datica db list DATABASE_NAME [-p] [-n]

List created backups

Arguments:
  DATABASE_NAME=""   The name of the database service to list backups for (e.g. 'db01')

Options:
  -p, --page=1         The page to view
  -n, --page-size=10   The number of items to show per page

db list lists all previously created backups. After listing backups you can copy the backup ID and use it to download that backup or view the logs from that backup. Here is a sample command

datica -E "" db list db01

Logs

Usage: datica db logs DATABASE_NAME BACKUP_ID

Print out the logs from a previous database backup job

Arguments:
  DATABASE_NAME=""   The name of the database service (e.g. 'db01')
  BACKUP_ID=""       The ID of the backup to download logs from (found from "datica backup list")

db logs allows you to view backup logs from historical backup jobs. You can find the backup ID from using the db list command. Here is a sample command

datica -E "" db logs db01 cd2b4bce-2727-42d1-89e0-027bf3f1a203

Deploy

Usage: datica deploy SERVICE_NAME IMAGE_NAME

Deploy a Docker image to a container service.

Arguments:
  SERVICE_NAME=""   The name of the service where the image will be deployed. (e.g. 'container-1')
  TAGGED_IMAGE=""   The name and tag of the image to deploy. (e.g. 'my-image:tag)

deploy deploys a Docker image for the given service. This command will only deploy for "container" services. Here is a sample command

datica -E "" deploy  :

Deploy-keys

The deploy-keys command gives access to SSH deploy keys for environment services. The deploy-keys command can not be run directly but has subcommands.

Add

Usage: datica deploy-keys add NAME KEY_PATH SERVICE_NAME

Add a new deploy key

Arguments:
  NAME=""           The name for the new key, for your own purposes
  KEY_PATH=""       Relative path to the SSH key file
  SERVICE_NAME=""   The name of the code service to add this deploy key to

deploy-keys add allows you to upload an SSH public key in OpenSSH format. These keys are used for pushing code to your code services but are not required. You should be using personal SSH keys with the keys command unless you are pushing code from Continuous Integration or Continuous Deployment scenarios. Deploy keys are intended to be shared among an organization. Here are some sample commands

datica -E "" deploy-keys add app01_public ~/.ssh/app01_rsa.pub app01

List

Usage: datica deploy-keys list SERVICE_NAME

List all deploy keys

Arguments:
  SERVICE_NAME=""   The name of the code service to list deploy keys

deploy-keys list will list all of your previously uploaded deploy keys by name including the key's fingerprint in SHA256 format. Here is a sample command

datica -E "" deploy-keys list app01

Rm

Usage: datica deploy-keys rm NAME SERVICE_NAME

Remove a deploy key

Arguments:
  NAME=""           The name of the key to remove
  SERVICE_NAME=""   The name of the code service to remove this deploy key from

deploy-keys rm will remove a previously created deploy key by name. It is a good idea to rotate deploy keys on a set schedule as they are intended to be shared among an organization. Here are some sample commands

datica -E "" deploy-keys rm app01_public app01

Images

images allows interactions with container images and tags. This command cannot be run directly, but has subcommands.

List

Usage: datica images list

List images available for an environment

images list lists available images for an environment. These images must be pushed to the registry for the environment and deployed in order to show. Here is a sample command:

datica -E "" images list

Push

Usage: datica images push TAGGED_IMAGE

Push an image for your environment

Arguments:
  TAGGED_IMAGE=""   The name of the image to push. (e.g. 'my-image:tag')

images push pushes a new image to the registry for your environment. The image will be retagged with the Datica registry and your namespace appended to the front if not provided. If no tag is specified, the image will be tagged "latest" Note: Pushed images will not be returned by the `images list` command until they have been deployed. Here is a sample command:

datica -E "" images push :

Pull

Usage: datica images pull TAGGED_IMAGE

Pull an image from your environment namespace

Arguments:
  TAGGED_IMAGE=""   The name of the image to pull. (e.g. 'my-image:tag')

images pull pulls an image from the registry for your environment and verifies its content against a signed target. The image will be pulled with the Datica registry and your environment namespace appended to the front if not provided. Here is a sample command:

datica -E "" images pull :

Targets

targets allows interactions with content verified targets in a repository. This command cannot be run directly, but has subcommands.

List

Usage: datica images targets list IMAGE_NAME

List signed targets for an image

Arguments:
  IMAGE_NAME=""   The name of the image to list targets for. (e.g. 'my-image')

images targets list lists signed targets for an image. To search for a specific target, specify a tag with the image name in the format "image:tag" Here is a sample command:

datica -E "" images targets list 

Rm

Usage: datica images targets rm TAGGED_IMAGE

Delete a signed target for a given image

Arguments:
  TAGGED_IMAGE=""   The name and tag of the image to delete targets from. (e.g. 'my-image:tag')

images targets rm deletes a signed target for a given image. You environment namespace will be filled in for you if not provided. Here is a sample command:

datica -E "" images targets rm :

Status

Usage: datica images targets status IMAGE_NAME

List local unpublished changes to the trust repository for an image

Arguments:
  IMAGE_NAME=""   The name of the image to list unpublished changes for. (e.g. 'my-image')

images targets status lists unpublished changes to a local trust repository. To search for changes to a specific target, specify a tag with the image name in the format "image:tag". Here is a sample command:

datica -E "" images targets status 

Reset

Usage: datica images targets reset IMAGE_NAME

Clear unpublished changes in the local trust repository for an image

Arguments:
  IMAGE_NAME=""   The name of the image to reset unpublished changes for. (e.g. 'my-image')

images targets reset clears unpublished changes in a local trust repository. This does not affect your remote trust repository. To reset changes for a specific target, specify a tag with the image name in the format "image:tag". Here is a sample command:

datica -E "" images targets reset 

Tags

tags allows interactions with container image tags. This command cannot be run directly, but has subcommands.

List

Usage: datica images tags list IMAGE_NAME

List tags for a given image

Arguments:
  IMAGE_NAME=""   The name of the image to list tags for. (e.g. 'my-image')

List pushed tags for given image. Example:

datica -E "" images tags list 

Rm

Usage: datica images tags rm TAGGED_IMAGE

Delete a tag for a given image

Arguments:
  TAGGED_IMAGE=""   The name and tag of the image to delete. (e.g. 'my-image:tag')

Delete a tag for a given image. Example:

datica -E "" images tags rm :

Domain

Usage: datica domain

Print out the temporary domain name of the environment

domain prints out the temporary domain name setup by Datica for an environment. This domain name typically takes the form podXXXXX.catalyzeapps.com but may vary based on the environment. Here is a sample command

datica -E "" domain

Environments

The environments command allows you to manage your environments. The environments command can not be run directly but has subcommands.

List

Usage: datica environments list

List all environments you have access to

environments list lists all environments that you are granted access to. These environments include those you created and those that other Datica customers have added you to. Here is a sample command

datica environments list

Rename

Usage: datica environments rename NAME

Rename an environment

Arguments:
  NAME=""      The new name of the environment

environments rename allows you to rename your environment. Here is a sample command

datica -E "" environments rename MyNewEnvName

Files

The files command gives access to service files on your environment's services. Service files can include Nginx configs, SSL certificates, and any other file that might be injected into your running service. The files command can not be run directly but has subcommands.

Download

Usage: datica files download [SERVICE_NAME] FILE_NAME [-o] [-f]

Download a file to your localhost with the same file permissions as on the remote host or print it to stdout

Arguments:
  SERVICE_NAME="service_proxy"   The name of the service to download a file from
  FILE_NAME=""                   The name of the service file from running "datica files list"

Options:
  -o, --output=""     The downloaded file will be saved to the given location with the same file permissions as it has on the remote host. If those file permissions cannot be applied, a warning will be printed and default 0644 permissions applied. If no output is specified, stdout is used.
  -f, --force=false   If the specified output file already exists, automatically overwrite it

files download allows you to view the contents of a service file and save it to your local machine. Most service files are stored on your service_proxy and therefore you should not have to specify the SERVICE_NAME argument. Simply supply the FILE_NAME found from the files list command and the contents of the file, as well as the permissions string, will be printed to your console. You can always store the file locally, applying the same permissions as those on the remote server, by specifying an output file with the -o flag. Here is a sample command

datica -E "" files download /etc/nginx/sites-enabled/mywebsite.com

List

Usage: datica files list [SERVICE_NAME] [-t]

List all files available for a given service

Arguments:
  SERVICE_NAME="service_proxy"   The name of the service to list files for

Options:
  -t, --showTimestamps=false   Show when each file was created and most recently updated

files list prints out a listing of all service files available for download. Nearly all service files are stored on the service_proxy and therefore you should not have to specify the SERVICE_NAME argument. Here is a sample command

datica -E "" files list

Git-remote

The git-remote command allows you to interact with code service remote git URLs. The git-remote command can not be run directly but has subcommands.

Add

Usage: datica git-remote add SERVICE_NAME [-r] [-f]

Add the git remote for the given code service to the local git repo

Arguments:
  SERVICE_NAME=""   The name of the service to add a git remote for

Options:
  -r, --remote="datica"   The name of the git remote to be added
  -f, --force=false       If a git remote with the specified name already exists, overwrite it

git-remote add adds the proper git remote to a local git repository with the given remote name and service. Here is a sample command

datica -E "" git-remote add code-1 -r datica-code-1

Show

Usage: datica git-remote show SERVICE_NAME

Print out the git remote for a given code service

Arguments:
  SERVICE_NAME=""   The name of the service to add a git remote for

git-remote show prints out the git remote URL for the given service. This can be used to do a manual push or use the git remote for another purpose such as a CI integration. Here is a sample command

datica -E "" git-remote show code-1

Init

Usage: datica init

Get started using the Datica platform

The init command walks you through setting up the CLI to use with the Datica platform. The init command requires you to have an environment already set up.

Invites

The invites command gives access to organization invitations. Every environment is owned by an organization and users join organizations in order to access individual environments. You can invite new users by email and manage pending invites through the CLI. You cannot call the invites command directly, but must call one of its subcommands.

Accept

Usage: datica invites accept INVITE_CODE

Accept an organization invite

Arguments:
  INVITE_CODE=""   The invite code that was sent in the invite email

invites accept is an alternative form of accepting an invitation sent by email. The invitation email you receive will have instructions as well as the invite code to use with this command. Here is a sample command

datica -E "" invites accept 5a206aa8-04f4-4bc1-a017-ede7e6c7dbe2

List

Usage: datica invites list

List all pending organization invitations

invites list lists all pending invites for an environment's organization. Any invites that have already been accepted will not appear in this list. To manage users who have already accepted invitations or are already granted access to your environment, use the users group of commands. Here is a sample command

datica -E "" invites list

Rm

Usage: datica invites rm INVITE_ID

Remove a pending organization invitation

Arguments:
  INVITE_ID=""   The ID of an invitation to remove

invites rm removes a pending invitation found by using the invites list command. Once an invite has already been accepted, it cannot be removed. Removing an invitation is helpful if an email was misspelled or an invitation was sent to an incorrect email address. If you want to revoke access to a user who already has been given access to your environment, use the users rm command. Here is a sample command

datica -E "" invites rm 78b5d0ed-f71c-47f7-a4c8-6c8c58c29db1

Send

Usage: datica invites send EMAIL

Send an invite to a user by email for a given organization

Arguments:
  EMAIL=""     The email of a user to invite to an environment. This user does not need to have a Datica account prior to sending the invitation

invites send invites a new user to your environment's organization. The only piece of information required is the email address to send the invitation to. The invited user will join the organization with no permissions. You must grant them permission through the dashboard. The recipient does not need to have a Dashboard account in order to send them an invitation. However, they will need to have a Dashboard account to accept the invitation. Here is a sample command

datica -E "" invites send coworker@datica.com

Jobs

The jobs command allows you to manage jobs for your service(s). The jobs command cannot be run directly but has subcommands.

List

Usage: datica jobs list SERVICE_NAME

List all jobs for a service

Arguments:
  SERVICE_NAME=""   The name of the service to list jobs for

jobs list prints out a list of all jobs in your environment and their current status. Here is a sample command:

datica -E "" jobs list 

Start

Usage: datica jobs start SERVICE_NAME JOB_ID

Start a specific job within a service

Arguments:
  SERVICE_NAME=""   The name of the service to list jobs for
  JOB_ID=""         The job ID for the job in service to be started

jobs start will start a job that is configured but not currently running within a given service. This command is useful for granual control of your services and their workers, tasks, etc.

datica -E "" jobs start  

Stop

Usage: datica jobs stop [SERVICE_NAME] [JOB_ID] [-f]

Stop a specific job within a service

Arguments:
  SERVICE_NAME=""   The name of the service to list jobs for
  JOB_ID=""         The job ID for the job in service to be stopped

Options:
  -f, --force=false   Allow this command to be executed without prompting to confirm

jobs stop will shut down a running job within a given service. This command is useful for granular control of your services and their workers, tasks, etc.

datica -E "" jobs stop  

Keys

The keys command gives access to SSH key management for your user account. SSH keys can be used for authentication and pushing code to the Datica platform. Any SSH keys added to your user account should not be shared but be treated as private SSH keys. Any SSH key uploaded to your user account will be able to be used with all code services and environments that you have access to. The keys command can not be run directly but has subcommands.

Add

Usage: datica keys add NAME PUBLIC_KEY_PATH

Add a public key

Arguments:
  NAME=""              The name for the new key, for your own purposes
  PUBLIC_KEY_PATH=""   Relative path to the public key file

keys add allows you to add a new SSH key to your user account. SSH keys added to your user account should be private and not shared with others. SSH keys can be used for authentication (as opposed to the traditional email and password) as well as pushing code to an environment's code services. Please note, you must specify the path to the public key file and not the private key. All SSH keys should be in either OpenSSH RSA format or PEM format. Here is a sample command

datica keys add my_prod_key ~/.ssh/prod_rsa.pub

List

Usage: datica keys list

List your public keys

keys list lists all public keys by name that have been uploaded to your user account including the key's fingerprint in SHA256 format. Here is a sample command

datica keys list

Rm

Usage: datica keys rm NAME

Remove a public key

Arguments:
  NAME=""      The name of the key to remove.

keys rm allows you to remove an SSH key previously uploaded to your account. The name of the key can be found by using the keys list command. Here is a sample command

datica keys rm my_prod_key

Set

Usage: datica keys set PRIVATE_KEY_PATH

Set your auth key

Arguments:
  PRIVATE_KEY_PATH=""   Relative path to the private key file

keys set allows the CLI to use an SSH key for authentication instead of the traditional email and password combination. This can be useful for automation or where shared workstations are involved. Please note that you must pass in the path to the private key and not the public key. The given key must already be added to your account by using the keys add command. Here is a sample command

datica keys set ~/.ssh/my_key

Logout

Usage: datica logout

Clear the stored user information from your local machine

When using the CLI, your email and password are never stored in any file on your filesystem. However, in order to not type in your email and password each and every command, a session token is stored in the CLI's configuration file and used until it expires. logout removes this session token from the configuration file. Here is a sample command

datica logout

Logs

Usage: datica logs [QUERY] [(-f | -t)] [--hours] [--minutes] [--seconds] [--service [(--job-id | --target)]]

Show the logs in your terminal streamed from your logging dashboard

Arguments:
  QUERY="*"    The query to send to your logging dashboard's elastic search (regex is supported)

Options:
  -f, --follow=false   Tail/follow the logs (Equivalent to -t)
  -t, --tail=false     Tail/follow the logs (Equivalent to -f)
  --hours=0            The number of hours before now (in combination with minutes and seconds) to retrieve logs
  --minutes=0          The number of minutes before now (in combination with hours and seconds) to retrieve logs
  --seconds=0          The number of seconds before now (in combination with hours and minutes) to retrieve logs
  --service=""         Query logs for a specific service label
  --job-id=""          Query logs for a particular job by id
  --target=""          Query logs for a particular procfile target

logs prints out your application logs directly from your logging Dashboard. If you do not see your logs, try adjusting the number of hours, minutes, or seconds of logs that are retrieved with the --hours, --minutes, and --seconds options respectively. To specify a specific service, job, or target use the '--service', '--job-id', and '--target' commands. You must specify a service to use '--job-id' or '--target', and you cannot specify both a job-id and a target at the same time. You can also follow the logs with the -f option. When using -f all logs will be printed to the console within the given time frame as well as any new logs that are sent to the logging Dashboard for the duration of the command. When using the -f option, hit ctrl-c to stop. Here are some sample commands

datica -E "" logs --hours=6 --minutes=30
datica -E "" logs -f
datica -E "" logs --service=""
datica -E "" logs --service="" --job-id=""

Maintenance

Maintenance mode can be enabled or disabled for code services on demand. This redirects all traffic to a default maintenance page.

Disable

Usage: datica maintenance disable SERVICE_NAME

Disable maintenance mode for a code service

Arguments:
  SERVICE_NAME=""   The name of the service to disable maintenance mode for

maintenance disable turns off maintenance mode for a given code service. Here is a sample command

datica -E "" maintenance disable code-1

Enable

Usage: datica maintenance enable SERVICE_NAME

Enable maintenance mode for a code service

Arguments:
  SERVICE_NAME=""   The name of the code service to enable maintenance mode for

maintenance enable turns on maintenance mode for a given code service. Maintenance mode redirects all traffic for the given code service to a default HTTP maintenance page. If you would like to customize this maintenance page, please contact Datica support. Here is a sample command

datica -E "" maintenance enable code-1

Show

Usage: datica maintenance show [SERVICE_NAME]

Show the status of maintenance mode for a code service

Arguments:
  SERVICE_NAME=""   The name of the code service to show the status of maintenance mode

maintenance show displays whether or not maintenance mode is enabled for a code service or all code services. Here are some sample commands

datica -E "" maintenance show
datica -E "" maintenance show code-1

Metrics

The metrics command gives access to environment metrics or individual service metrics through a variety of formats. This is useful for checking on the status and performance of your application or environment as a whole. The metrics command cannot be run directly but has subcommands.

Cpu

Usage: datica metrics cpu [SERVICE_NAME] [(--json | --csv | --text)] [--stream] [-m]

Print service and environment CPU metrics in your local time zone

Arguments:
  SERVICE_NAME=""   The name of the service to print metrics for

Options:
  --json=false     Output the data as json
  --csv=false      Output the data as csv
  --text=true      Output the data in plain text
  --stream=false   Repeat calls once per minute until this process is interrupted.
  -m, --mins=1     How many minutes worth of metrics to retrieve.

metrics cpu prints out CPU metrics for your environment or individual services. You can print out metrics in csv, json, plain text, or spark lines format. If you want plain text format, omit the --json and --csv flags. You can only stream metrics using plain text or spark lines formats. To print out metrics for every service in your environment, omit the SERVICE_NAME argument. Otherwise you may choose a service, such as an app service, to retrieve metrics for. Here are some sample commands

datica -E "" metrics cpu
datica -E "" metrics cpu app01 --stream
datica -E "" metrics cpu --json
datica -E "" metrics cpu db01 --csv -m 60

Memory

Usage: datica metrics memory [SERVICE_NAME] [(--json | --csv | --text)] [--stream] [-m]

Print service and environment memory metrics in your local time zone

Arguments:
  SERVICE_NAME=""   The name of the service to print metrics for

Options:
  --json=false     Output the data as json
  --csv=false      Output the data as csv
  --text=true      Output the data in plain text
  --stream=false   Repeat calls once per minute until this process is interrupted.
  -m, --mins=1     How many minutes worth of metrics to retrieve.

metrics memory prints out memory metrics for your environment or individual services. You can print out metrics in csv, json, plain text, or spark lines format. If you want plain text format, omit the --json and --csv flags. You can only stream metrics using plain text or spark lines formats. To print out metrics for every service in your environment, omit the SERVICE_NAME argument. Otherwise you may choose a service, such as an app service, to retrieve metrics for. Here are some sample commands

datica -E "" metrics memory
datica -E "" metrics memory app01 --stream
datica -E "" metrics memory --json
datica -E "" metrics memory db01 --csv -m 60

Network-in

Usage: datica metrics network-in [SERVICE_NAME] [(--json | --csv | --text)] [--stream] [-m]

Print service and environment received network data metrics in your local time zone

Arguments:
  SERVICE_NAME=""   The name of the service to print metrics for

Options:
  --json=false     Output the data as json
  --csv=false      Output the data as csv
  --text=true      Output the data in plain text
  --stream=false   Repeat calls once per minute until this process is interrupted.
  -m, --mins=1     How many minutes worth of metrics to retrieve.

metrics network-in prints out received network metrics for your environment or individual services. You can print out metrics in csv, json, plain text, or spark lines format. If you want plain text format, omit the --json and --csv flags. You can only stream metrics using plain text or spark lines formats. To print out metrics for every service in your environment, omit the SERVICE_NAME argument. Otherwise you may choose a service, such as an app service, to retrieve metrics for. Here are some sample commands

datica -E "" metrics network-in
datica -E "" metrics network-in app01 --stream
datica -E "" metrics network-in --json
datica -E "" metrics network-in db01 --csv -m 60

Network-out

Usage: datica metrics network-out [SERVICE_NAME] [(--json | --csv | --text)] [--stream] [-m]

Print service and environment transmitted network data metrics in your local time zone

Arguments:
  SERVICE_NAME=""   The name of the service to print metrics for

Options:
  --json=false     Output the data as json
  --csv=false      Output the data as csv
  --text=true      Output the data in plain text
  --stream=false   Repeat calls once per minute until this process is interrupted.
  -m, --mins=1     How many minutes worth of metrics to retrieve.

metrics network-out prints out transmitted network metrics for your environment or individual services. You can print out metrics in csv, json, plain text, or spark lines format. If you want plain text format, simply omit the --json and --csv flags. You can only stream metrics using plain text or spark lines formats. To print out metrics for every service in your environment, omit the SERVICE_NAME argument. Otherwise you may choose a service, such as an app service, to retrieve metrics for. Here are some sample commands

datica -E "" metrics network-out
datica -E "" metrics network-out app01 --stream
datica -E "" metrics network-out --json
datica -E "" metrics network-out db01 --csv -m 60

Rake

Usage: datica rake SERVICE_NAME TASK_NAME

Execute a rake task

Arguments:
  SERVICE_NAME=""   The service that will run the rake task.
  TASK_NAME=""      The name of the rake task to run

rake executes a rake task by its name asynchronously. Once executed, the output of the task can be seen through your logging Dashboard. Here is a sample command

datica -E "" rake code-1 db:migrate

Redeploy

Usage: datica redeploy SERVICE_NAME

Redeploy a service without having to do a git push. This will cause downtime for all redeploys (see the resources page for more details).

Arguments:
  SERVICE_NAME=""   The name of the service to redeploy (e.g. 'app01')

redeploy deploys an identical copy of the given service. For code services, this avoids having to perform a code push. You skip the git push and the build. For service proxies, new instances replace the old ones. All other service types cannot be redeployed with this command. For service proxy redeploys, there will be approximately 5 minutes of downtime. For code service redeploys, there will be approximately 30 seconds of downtime. Here is a sample command

datica -E "" redeploy app01

Releases

The releases command allows you to manage your code service releases. A release is automatically created each time you perform a git push. The release is tagged with the git SHA of the commit. Releases are a way of tagging specific points in time of your git history. By default, the last three releases will be kept. Please contact Support if you require more than the last three releases to be retained. You can rollback to a specific release by using the rollback command. The releases command cannot be run directly but has subcommands.

List

Usage: datica releases list SERVICE_NAME

List all releases for a given code service

Arguments:
  SERVICE_NAME=""   The name of the service to list releases for

releases list lists all of the releases for a given service. A release is automatically created each time a git push is performed. Here is a sample command

datica -E "" releases list code-1

Rm

Usage: datica releases rm SERVICE_NAME RELEASE_NAME

Remove a release from a code service

Arguments:
  SERVICE_NAME=""   The name of the service to remove a release from
  RELEASE_NAME=""   The name of the release to remove

releases rm removes an existing release. This is useful in the case of a misbehaving code service. Removing the release avoids the risk of rolling back to a "bad" build. Here is a sample command

datica -E "" releases rm code-1 f93ced037f828dcaabccfc825e6d8d32cc5a1883

Update

Usage: datica releases update SERVICE_NAME RELEASE_NAME [--notes]

Update a release from a code service

Arguments:
  SERVICE_NAME=""   The name of the service to update a release for
  RELEASE_NAME=""   The name of the release to update

Options:
  -n, --notes=""   The new notes to save on the release.

releases update allows you to rename or add notes to an existing release. By default, releases are named with the git SHA of the commit used to create the release. Renaming them allows you to organize your releases. Here is a sample command

datica -E "" releases update code-1 f93ced037f828dcaabccfc825e6d8d32cc5a1883 --notes "This is a stable build"

Rollback

Usage: datica rollback SERVICE_NAME RELEASE_NAME

Rollback a code service to a specific release

Arguments:
  SERVICE_NAME=""   The name of the service to rollback
  RELEASE_NAME=""   The name of the release to rollback to

rollback is a way to redeploy older versions of your code service. You must specify the name of the service to rollback and the name of an existing release to rollback to. Releases can be found with the releases list command. Here are some sample commands

datica -E "" rollback code-1 f93ced037f828dcaabccfc825e6d8d32cc5a1883

Services

The services command allows you to manage your services. The services command cannot be run directly but has subcommands.

List

Usage: datica services list

List all services for your environment

services list prints out a list of all services in your environment and their sizes. The services will be printed regardless of their currently running state. To see which services are currently running and which are not, use the status command. Here is a sample command

datica -E "" services list

Stop

Usage: datica services stop SERVICE_NAME

Stop all instances of a given service (including all workers, rake tasks, and open consoles)

Arguments:
  SERVICE_NAME=""   The name of the service to stop

services stop shuts down all running instances of a given service. This is useful when performing maintenance on code services or services without volumes that must be shutdown to perform maintenance. Take caution when running this command as all instances of the service, all workers, all rake tasks, and all open console sessions will be stopped. Here is a sample command

datica -E "" services stop code-1

Rename

Usage: datica services rename SERVICE_NAME NEW_NAME

Rename a service

Arguments:
  SERVICE_NAME=""   The service to rename
  NEW_NAME=""       The new name for the service

services rename allows you to rename any service in your environment. Here is a sample command

datica -E "" services rename code-1 api-svc

Sites

The sites command gives access to hostname and SSL certificate usage for public facing services. sites are different from certs in that sites use an instance of a cert and are associated with a single service. certs can be used by multiple sites. The sites command can not be run directly but has subcommands.

Create

Usage: datica sites create SITE_NAME SERVICE_NAME (CERT_NAME | -l) [--down-stream] [--client-max-body-size] [--proxy-connect-timeout] [--proxy-read-timeout] [--proxy-send-timeout] [--proxy-upstream-timeout] [--enable-cors] [--enable-websockets]

Create a new site linking it to an existing cert instance

Arguments:
  SITE_NAME=""      The name of the site to be created. This will be used in this site's nginx configuration file (e.g. ".example.com")
  SERVICE_NAME=""   The name of the service to add this site configuration to (e.g. 'app01')
  CERT_NAME=""      The name of the cert created with the 'certs' command (e.g. "star_example_com")

Options:
  --down-stream="service_proxy"   The name of the down-stream service. Defaults to "service_proxy"
  --client-max-body-size=-1       The 'client_max_body_size' nginx config specified in megabytes
  --proxy-connect-timeout=-1      The 'proxy_connect_timeout' nginx config specified in seconds
  --proxy-read-timeout=-1         The 'proxy_read_timeout' nginx config specified in seconds
  --proxy-send-timeout=-1         The 'proxy_send_timeout' nginx config specified in seconds
  --proxy-upstream-timeout=-1     The 'proxy_next_upstream_timeout' nginx config specified in seconds
  --enable-cors=false             Enable or disable all features related to full CORS support
  --enable-websockets=false       Enable or disable all features related to full websockets support
  -l, --lets-encrypt=false        Whether or not this site should create an auto-renewing Let's Encrypt certificate

sites create allows you to create a site configuration that is tied to a single service. To create a site, you must specify an existing cert made by the certs create command or use the "-l" flag to automatically create a Let's Encrypt certificate. A site has three pieces of information: a name, the service it's tied to, and the cert instance it will use. The name is the server_name that will be injected into this site's Nginx configuration file. It is important that this site name match what URL your site will respond to. If this is a bare domain, using mysite.com is sufficient. If it should respond to the APEX domain and all subdomains, it should be named .mysite.com notice the leading .. The service is a code service that will use this site configuration. Lastly, the cert instance must be specified by the CERT_NAME argument used in the certs create command or by the "-l" flag indicating a new Let's Encrypt certificate should be created. You can also set Nginx configuration values directly by specifying one of the above flags. Specifying --enable-cors will add the following lines to your Nginx configuration

add_header 'Access-Control-Allow-Origin' '$http_origin' always;
add_header 'Access-Control-Allow-Credentials' 'true' always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS, DELETE, PUT, HEAD, PATCH' always;
add_header 'Access-Control-Allow-Headers' 'DNT,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Accept,Authorization' always;
add_header 'Access-Control-Max-Age' 1728000 always;
if ($request_method = 'OPTIONS') {
  return 204;
}

Specifying --enable-websockets will add the following lines to your Nginx configuration

proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

Here are some sample commands

datica -E "" sites create .mysite.com app01 wildcard_mysitecom
datica -E "" sites create .mysite.com app01 wildcard_mysitecom --client-max-body-size 50 --enable-cors
datica -E "" sites create app01.mysite.com app01 --lets-encrypt --enable-websockets

List

Usage: datica sites list [--down-stream]

List details for all site configurations

Options:
  --down-stream="service_proxy"   The name of the down-stream service. Defaults to "service_proxy"

sites list lists all sites for the given environment. The names printed out can be used in the other sites commands. Here is a sample command

datica -E "" sites list

Rm

Usage: datica sites rm NAME

Remove a site configuration

Arguments:
  NAME=""      The name of the site configuration to delete

Options:
  --down-stream="service_proxy"   The name of the down-stream service. Defaults to "service_proxy"

sites rm allows you to remove a site by name. Since sites cannot be updated, if you want to change the name of a site, you must rm the site and then create it again. If you simply need to update your SSL certificates, you can use the certs update command on the cert instance used by the site in question. Here is a sample command

datica -E "" sites rm mywebsite.com

Show

Usage: datica sites show NAME [--down-stream]

Shows the details for a given site

Arguments:
  NAME=""      The name of the site configuration to show

Options:
  --down-stream="service_proxy"   The name of the down-stream service. Defaults to "service_proxy"

sites show will print out detailed information for a single site. The name of the site can be found from the sites list command. Here is a sample command

datica -E "" sites show mywebsite.com

Ssl

The ssl command offers access to subcommands that deal with SSL certificates. You cannot run the SSL command directly but must call a subcommand.

Resolve

Usage: datica ssl resolve CHAIN PRIVATE_KEY HOSTNAME [OUTPUT] [-f]

Verify that an SSL certificate is signed by a valid CA and attempt to resolve any incomplete certificate chains that are found

Arguments:
  CHAIN=""         The path to your full certificate chain in PEM format
  PRIVATE_KEY=""   The path to your private key in PEM format
  HOSTNAME=""      The hostname that should match your certificate (e.g. "*.datica.com")
  OUTPUT=""        The path of a file to save your properly resolved certificate chain (defaults to STDOUT)

Options:
  -f, --force=false   If an output file is specified and already exists, setting force to true will overwrite the existing output file

ssl resolve is a tool that will attempt to fix invalid SSL certificates chains. A well formatted SSL certificate will include your certificate, intermediate certificates, and root certificates. It should follow this format

-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----

If your certificate only includes your own certificate, such as the following format shows

-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----

then the SSL resolve command will attempt to resolve this by downloading public intermediate certificates and root certificates. A general rule of thumb is, if your certificate passes the ssl resolve check, it will almost always work on the Datica platform. You can specify where to save the updated chain or omit the OUTPUT argument to print it to STDOUT. Please note you all certificates and private keys should be in PEM format. You cannot use self signed certificates with this command as they cannot be resolved as they are not signed by a valid CA. Here are some sample commands

datica ssl resolve ~/mysites_cert.pem ~/mysites_key.key *.mysite.com ~/updated_mysites_cert.pem -f
datica ssl resolve ~/mysites_cert.pem ~/mysites_key.key *.mysite.com

Verify

Usage: datica ssl verify CHAIN PRIVATE_KEY HOSTNAME [-s]

Verify whether a certificate chain is complete and if it matches the given private key

Arguments:
  CHAIN=""         The path to your full certificate chain in PEM format
  PRIVATE_KEY=""   The path to your private key in PEM format
  HOSTNAME=""      The hostname that should match your certificate (e.g. "*.datica.com")

Options:
  -s, --self-signed=false   Whether or not the certificate is self signed. If set, chain verification is skipped

ssl verify will tell you if your SSL certificate and private key are properly formatted for use with Datica's Compliant Cloud. Before uploading a certificate to Datica you should verify it creates a full chain and matches the given private key with this command. Both your chain and private key should be unencrypted and in PEM format. The private key is the only key in the key file. However, for the chain, you should include your SSL certificate, intermediate certificates, and root certificate in the following order and format.

-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----

-----END CERTIFICATE-----

This command also requires you to specify the hostname that you are using the SSL certificate for in order to verify that the hostname matches what is in the chain. If it is a wildcard certificate, your hostname would be in the following format: *.datica.com. This command will verify a complete chain can be made from your certificate down through the intermediate certificates all the way to a root certificate that you have given or one found in your system. You can also use this command to verify self-signed certificates match a given private key. To do so, add the -s option which will skip verifying the certificate to root chain and just tell you if your certificate matches your private key. Please note that the empty quotes are required for checking self signed certificates. This is the required parameter HOSTNAME which is ignored when checking self signed certificates. Here are some sample commands

datica ssl verify ./datica.crt ./datica.key *.datica.com
datica ssl verify ~/self-signed.crt ~/self-signed.key "" -s

Status

Usage: datica status [--historical]

Get quick readout of the current status of an environment and all of its services

Options:
  --historical=false   If this option is specified, a complete history of jobs will be reported

status will give a quick readout of your environment's health. This includes your environment name, environment ID, and for each service the name, size, build status, deploy status, and service ID. Here is a sample command

datica -E "" status
datica -E "" status --historical

Support-ids

Usage: datica support-ids

Print out various IDs related to an environment to be used when contacting Datica support

support-ids is helpful when contacting Datica support by submitting a ticket at https://datica.com/support. If you are having an issue with a CLI command or anything with your environment, it is helpful to run this command and copy the output into the initial correspondence with a Datica engineer. This will help Datica identify the environment faster and help come to resolution faster. Here is a sample command

datica -E "" support-ids

Update

Usage: datica update

Checks for available updates and updates the CLI if a new update is available

update is a shortcut to update your CLI instantly. If a newer version of the CLI is available, it will be downloaded and installed automatically. This is used when you want to apply an update before the CLI automatically applies it on its own. Here is a sample command

datica update

Users

The users command allows you to manage who has access to your environment through the organization that owns the environment. The users command can not be run directly but has three subcommands.

List

Usage: datica users list

List all users who have access to the given organization

users list shows every user that belongs to your environment's organization. Users who belong to your environment's organization may access to your environment's services and data depending on their role in the organization. Here is a sample command

datica -E "" users list

Rm

Usage: datica users rm EMAIL

Revoke access to the given organization for the given user

Arguments:
  EMAIL=""     The email address of the user to revoke access from for the given organization

users rm revokes a users access to your environment's organization. Revoking a user's access to your environment's organization will revoke their access to your organization's environments. Here is a sample command

datica -E "" users rm user@example.com

Vars

The vars command allows you to manage environment variables for your code services. The vars command can not be run directly but has subcommands.

List

Usage: datica vars list SERVICE_NAME [--json | --yaml]

List all environment variables

Arguments:
  SERVICE_NAME=""   The name of the service containing the environment variables.

Options:
  --json=false   Output environment variables in JSON format
  --yaml=false   Output environment variables in YAML format

vars list prints out all known environment variables for the given code service. You can print out environment variables in JSON or YAML format through the --json or --yaml flags. Here are some sample commands

datica -E "" vars list code-1
datica -E "" vars list code-1 --json

Set

Usage: datica vars set SERVICE_NAME (-v... | -f)

Set one or more new environment variables or update the values of existing ones

Arguments:
  SERVICE_NAME=""   The name of the service on which the environment variables will be set.

Options:
  -v, --variable    The env variable to set or update in the form "="
  -f, --file=""     The path to a file to import environment variables from. This file can be in JSON, YAML, or KEY=VALUE format

vars set allows you to add new environment variables or update the value of an existing environment variable on the given code service. You can set/update 1 or more environment variables at a time with this command by repeating the -v option multiple times. Once new environment variables are added or values updated, a redeploy is required for the given code service to have access to the new values. The environment variables must be of the form =. Here is a sample command

datica -E "" vars set code-1 -v AWS_ACCESS_KEY_ID=1234 -v AWS_SECRET_ACCESS_KEY=5678

Unset

Usage: datica vars unset SERVICE_NAME VARIABLE...

Unset (delete) an existing environment variable

Arguments:
  SERVICE_NAME=""   The name of the service on which the environment variables will be unset.
  VARIABLE          The names of environment variables to unset

vars unset removes environment variables from the given code service. Only the environment variable name is required to unset. Once environment variables are unset, a redeploy is required for the given code service to realize the variable was removed. You can unset any number of environment variables in one command. Here is a sample command

datica -E "" vars unset code-1 AWS_ACCESS_KEY_ID AWS_SECRET_ACCES_KEY_ID

Version

Usage: datica version

Output the version and quit

version prints out the current CLI version as well as the architecture it was built for (64-bit or 32-bit). This is useful to see if you have the latest version of the CLI and when working with Datica support engineers to ensure you have the correct CLI installed. Here is a sample command

datica version

Whoami

Usage: datica whoami

Retrieve your user ID

whoami prints out the currently logged in user's users ID. This is used with Datica support engineers. Here is a sample command

datica whoami

Worker

The worker command allows to deploy, list, remove, and scale the workers in a code service.

Deploy

Usage: datica worker deploy SERVICE_NAME TARGET

Deploy new workers for a given service

Arguments:
  SERVICE_NAME=""   The name of the service to use to deploy a worker
  TARGET=""         The name of the Procfile target to invoke as a worker

worker deploy allows you to start a background process asynchronously. The TARGET must be specified in your Procfile. Once the worker is started, any output can be found in your logging Dashboard or using the logs command. Here is a sample command

datica -E "" worker deploy code-1 mailer

List

Usage: datica worker list SERVICE_NAME

Lists all workers for a given service

Arguments:
  SERVICE_NAME=""   The name of the service to list workers for

worker list lists all workers and their scale for a given code service along with the number of currently running instances of each worker target. Here is a sample command

datica -E "" worker list code-1

Rm

Usage: datica worker rm SERVICE_NAME TARGET

Remove all workers for a given service and target

Arguments:
  SERVICE_NAME=""   The name of the service running the workers
  TARGET=""         The worker target to remove

worker rm removes a worker by the given TARGET and stops all currently running instances of that TARGET. Here is a sample command

datica -E "" worker rm code-1 mailer

Scale

Usage: datica worker scale SERVICE_NAME TARGET SCALE

Scale existing workers up or down for a given service and target

Arguments:
  SERVICE_NAME=""   The name of the service running the workers
  TARGET=""         The worker target to scale up or down
  SCALE=""          The new scale (or change in scale) for the given worker target. This can be a single value (e.g. 2) representing the final number of workers that should be running. Or this can be a change represented by a plus or minus sign followed by the value (e.g. +2 or -1). When using a change in value, be sure to insert the "--" operator to signal the end of options. For example, "datica worker scale code-1 worker -- -1"

worker scale allows you to scale up or down a given worker TARGET. Scaling up will launch new instances of the worker TARGET while scaling down will immediately stop running instances of the worker TARGET if applicable. Here are some sample commands

datica -E "" worker scale code-1 mailer 1
datica -E "" worker scale code-1 mailer -- -2