Remote Development Quickstart

After your application has been onboarded to Velocity, you'll be able to log in with your company account and begin developing in your Velocity Environment.
This guide will walk you through the steps to get started developing and debugging an onboarded application remotely with the Velocity plugin for JetBrains IDEs.
Remote development and debugging is useful for the following reasons:
  • Lower Latency - If your application communicates with external services, developing and debugging locally introduces latency between your computer and the external service endpoint.
  • Reduced resource consumption - If your application consumes a lot of resources or if your local machine is low on resources, the development and debugging experience can degrade.
  • Reduced drift - Developing and debugging your application on the remote container bears a lower level of drift than offloading it locally. The container configuration stays the same as in the cloud, and you do not need to install specific environment tools in a specific version.

1. Log in to your company account

Navigate to and sign in to your company account.

2. Install the CLI

# via Homebrew
brew install techvelocity/tap/veloctl
# or with a script
curl -fsSL | sh -s
# Via snapcraft
sudo snap install veloctl --classic
# or with a script
curl -fsSL | sh -s

3. Authenticate to Velocity

veloctl auth login
When you run the above, you'll be redirected to the following confirmation modal. Click "Confirm".
After clicking "Confirm", you'll see a confirmation page. Close the tab and go back to your terminal.
Confirm that you are welcomed with your expected account name:
Attempting to automatically open the login page in your default browser.
If the browser does not open or you wish to use a different device to authorize this request, open the following URL:
and verify the following code appears:
* Fetching underlying Kubernetes cluster configuration...
* Stored context 'velocity-VELOACME' locally (`/Users/Marty/.kube/config`).
Welcome, Marty McFly ([email protected])!

3. Install the JetBrains IDE plugin

Search for "plugins" using the available icon in the top right of the screen. Then, search for "Velocity" in the Preferences>Plugins view, and click "Install."

4. Install `rsync` locally

Next, you'll need to install rsync locally to sync local code changes to the remotely running Velocity Environment. To do so, you can run the following:
# via Homebrew
brew install rsync
# via apt-get
apt-get update
apt-get install rsync

5. Configure .velocity.yaml

Then, you'll need to create a new file called .velocity.yaml locally in the root directory of your Velocity Service's src:
version: 1
args: [-f ./Dockerfile .]
You can paste the above into your .velocity.yaml file to get started. This will enable remote builds of your application container when code changes are detected.
NOTE: update the filepath to your Dockerfile as needed.

Live Updates for Interpreted Languages

For interpreted languages, such as Python and Ruby, you can enable hot reloading of your code changes, so the remote container won't need to be rebuilt on every detected code change. Instead, your local code changes will be copied into the remotely running container.
NOTE: Velocity's Live Updates feature requires rsync to be installed both locally and in the Velocity Service's container image. See Env Sync Tutorial with Python for details.
For a full list of available configurations, see Env Sync Configuration.

6. Add env sync run configuration

Finally, with the Velocity plugin installed, you can use your existing IntelliJ Run Configurations to create Velocity-specific run configurations that will allow you to develop and debug in your remote Velocity Environment.
To do so, click the "+" icon shown above and select "Velocity" from the dropdown. Next, you'll need to:
  • give your Velocity Run Configuration a name
  • select "Store as project file"
  • select your existing Run Configuration from the dropdown labeled "Run Configuration name"
  • select "Sync" and optionally add a Remote debugging local port
  • select the Velocity Service name associated with the service you are developing
  • click "OK" to save your configurations

7. Create a Velocity Environment

When you click the "+" icon shown above, you will be redirected to the Velocity UI, as shown below. You can then select the Velocity Services you'd like to develop or debug, and click "Create the Environment."
Next, you'll need to select the newly created Velocity Environment in the bottom right of your IntelliJ IDE.

8. Start developing

With the above in place, you can click the debug icon at the top of your IDE in order to start a remote development session, like so:
And you should see output similar to the following in your IDE:
Great work! Now you can begin developing your Velocity Service remotely!

Next Steps: