Publishing
API/Application Deployment Options
You can deploy a variety of APIs and applications using sub-commands of the rsconnect deploy
command.
api
: WSGI-compliant APIs such as Flask and packages based on Flaskfastapi
: ASGI-compliant APIs (FastAPI, Quart, Sanic, and Falcon)shiny
: Python Shiny appsdash
: Python Dash appsstreamlit
: Streamlit appsbokeh
: Bokeh server apps
All options below apply equally to the api
, fastapi
, shiny
, dash
, streamlit
, and bokeh
sub-commands.
Including Extra Files
You can include extra files in the deployment bundle to make them available when your API or application is run by the Posit Connect server. Just specify them on the command line after the API or application directory:
rsconnect deploy api flask-api/ data.csv
Since deploying an API or application starts at a directory level, there will be times when some files under that directory subtree should not be included in the deployment or manifest. Use the --exclude
option to specify files or directories to exclude.
rsconnect deploy dash \
--exclude dash-app-venv \
--exclude TODO.txt \
dash-app/
You can exclude a directory by naming it:
rsconnect deploy dash \
--exclude dash-app-venv \
--exclude output/ \
dash-app/
The --exclude
option may be repeated, and may include a glob pattern. You should always quote a glob pattern so that it will be passed to rsconnect
as-is instead of letting the shell expand it. If a file is specifically listed as an extra file that also matches an exclusion pattern, the file will still be included in the deployment (i.e., extra files take precedence).
rsconnect deploy dash \
--exclude dash-app-venv \
--exclude "*.txt" \
dash-app/
The following shows an example of an extra file taking precedence:
rsconnect deploy dash \
--exclude "*.csv" \
\
dash-app/ important_data.csv
Some directories are excluded by default, to prevent bundling and uploading files that are not needed or might interfere with the deployment process:
.Rproj.user
.env
.git
.svn
.venv
__pycache__
env
packrat
renv
rsconnect-python
rsconnect venv
Understanding entrypoints
APIs, Shiny Apps, and Dash Apps
When deploying a Python API, Shiny app, or Dash app, Posit Connect needs to locate the application object. The location of the application object is called the entrypoint and is specified in two parts, separated by a colon: the module name and the object name (optional). For example, app:app
if both are specified; or simply app
if only the module name is specified.
The module name is the name of a Python module that contains the application. For example, if your application code is in a file named example.py
in the application directory, then the module name would be example
.
The object name is the name of the application object in your Python code. In a Flask API, for example, the application is typically created by a line of code that looks like:
# example.py
# ...
= Flask(__name__) app
In this case, the application object is named app
, and the entrypoint would be example:app
.
If the object_name is omitted, Connect will attempt to find a default application in the following order:
app
application
create_app
make_app
create_app
and make_app
are expected to be factory functions, which should take no arguments and should return a valid application object.
If you are using rsconnect-python
, the default entrypoint is app
. If you put your code in app.py
and your application object is one of the defaults listed above, the default entrypoint will work.
Otherwise, specify the entrypoint on the command line using the --entrypoint
option. For example, if your code is in the file example.py
and your application object is named myapp
, use:
For Flask:
rsconnect deploy api \
-n <saved server name> \
--entrypoint example:myapp ...
For FastAPI:
rsconnect deploy fastapi \
-n <saved server name> \
--entrypoint example:myapp ...
Shiny for Python:
rsconnect deploy shiny
-n <saved server name> \
--entrypoint example:myapp ...
If you are creating a manifest.json file for later deployment, you can use:
For Flask:
rsconnect write-manifest api --entrypoint example:myapp ...
For FastAPI:
rsconnect write-manifest fastapi --entrypoint example:myapp ...
Shiny for Python:
rsconnect write-manifest shiny --entrypoint example:myapp ...
Streamlit and Bokeh Apps
For Streamlit and Bokeh apps, the entrypoint is the name of the Python file containing your app. For example, if your streamlit app’s source file is named main.py
, use:
rsconnect deploy streamlit \
-n <saved server name> \
--entrypoint main.py ...
Creating a Manifest for Future Deployment
You can create a manifest.json
file for an API or application, then use that manifest in a later deployment. Use the write-manifest
command to do this.
The write-manifest
command will also create a requirements.txt
file, if it does not already exist or the --force-generate
option is specified. It will contain the package dependencies from the current Python environment, or from an alternative Python executable specified in the --python
option or via the RETICULATE_PYTHON
environment variable.
Here is an example of the write-manifest
command:
rsconnect write-manifest api my-api/