# AppSail


--------------------------------------------------------------------------------
title: "Introduction"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.633Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/introduction/"
service: "Serverless"
--------------------------------------------------------------------------------


# AppSail

## Introduction

### Overview

Catalyst AppSail, a component of {{%link href=&#34;/en/serverless/&#34; %}}Catalyst Serverless{{%/link%}}, is a fully-managed, independent, platform for deploying web services to the cloud with ease. AppSail provides you with a powerful and highly-scalable platform to deploy anything from simple web apps to large enterprise applications, without any infrastructure setup or management concerns.

You can deploy a web service to Catalyst AppSail in one of these ways- 

* {{%bold%}}As a Catalyst-Managed Runtime:{{%/bold%}} Catalyst provides native support for web applications of specific **Java, Node.js, and Python** runtimes. You can directly deploy the build files of your application to AppSail in this case, to host it on the cloud. AppSail supports any frameworks, libraries, plugins, or dependencies of these supported runtimes that you might use in your application, provided they are not platform-dependant.  

* {{%bold%}}As a Custom Runtime:{{%/bold%}} You can deploy a container image (OCI image) of your application from any of these container registry services- {{%link href=&#34;https://hub.docker.com/&#34; %}}Docker Hub{{%/link%}}, {{%link href=&#34;https://aws.amazon.com/ecr/&#34; %}}AWS Elastic Container Registry{{%/link%}}, or {{%link href=&#34;https://cloud.google.com/artifact-registry/docs/overview&#34; %}}Google Artifact Registry{{%/link%}}, or a container image from your local registry. This custom runtime support enables you to develop and **deploy web services of any runtime or framework of your choice**. For example, you can deploy applications in PHP, Go, Ruby, or any runtime of Python, Java, or Node.js that are not supported natively by Catalyst.

{{%note%}}{{%bold%}}Note:{{%/bold%}} Catalyst only supports the deployment of {{%link href=&#34;https://github.com/opencontainers/image-spec&#34; %}}OCI-compliant images{{%/link%}} built for the Linux AMD64 (x86-64) platform.{{%/note%}}

Unlike {{%link href=&#34;/en/serverless/help/functions/introduction/&#34; %}}Catalyst Serverless functions{{%/link%}} that you code following a Catalyst-specific template based on the function type, AppSail services can be completely independent of any Catalyst-specific coding requirements. You can still employ any Catalyst component in your AppSail service through its {{%link href=&#34;/en/serverless/help/appsail/implement-catalyst-sdk&#34; %}}platform-specific SDK{{%/link%}}.

&lt;br&gt;

### Deployment Methods

You can deploy an AppSail service using any of these tools-

#### Deploy from the Catalyst CLI

* {{%bold%}}Catalyst-managed runtime:{{%/bold%}} You can {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} an AppSail service from the CLI, and {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail/&#34; %}}deploy{{%/link%}} it to the cloud from your local system for all Catalyst-managed runtimes. The CLI also supports a standalone deploy without prior initialization.

* {{%bold%}}Custom runtime:{{%/bold%}} You can deploy a container image of your app to the cloud from your local registry by initializing or adding it as an AppSail service similarly. Catalyst supports two protocols (as a Docker image or a Docker archive) for this purpose. You can do a standalone deploy as well.

{{%note%}}{{%bold%}}Note:{{%/bold%}} You can also {{%link href=&#34;/en/cli/v1/serve-resources/serve-all-resources/#serve-appsail-applications&#34; %}}test your app through a localhost{{%/link%}} before deploying it from the CLI. This is supported for apps deployed directly or as container images.{{%/note%}}

#### Deploy from the Catalyst Console

* {{%bold%}}Catalyst-managed runtime:{{%/bold%}} You can upload the build file of your application directly in the console in the Serverless section, configure the necessary details, and {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/deploy-from-console&#34; %}}deploy it instantly{{%/link%}}. 

* {{%bold%}}Custom runtime:{{%/bold%}} Catalyst enables you to {{%link href=&#34;/en/serverless/help/appsail/container-images/deploy-from-console&#34; %}}deploy a container image{{%/link%}} hosted on one of the supported cloud container registry services on AppSail by providing its URL and other details, after integrating with the registry service. 

&lt;br&gt;

### Instance and Platform Management

AppSail offers you complete control over your app&#39;s coding structure and execution. Catalyst enables you to perform a variety of {{%link href=&#34;/en/serverless/help/appsail/console/configurations/&#34; %}}configurations{{%/link%}} on your web service&#39;s execution environment, such as defining the memory and disk size to be allocated for its execution, the port it must be run on, environment variables required for your app, or the app&#39;s startup command.

You can access all the apps you deploy through the {{%link href=&#34;/en/serverless/help/appsail/console/overview/#appsail-url&#34; %}}AppSail URL{{%/link%}} that Catalyst will generate automatically. Additionally, you have the option to map your own domain to an AppSail service and access it through your {{%link href=&#34;/en/cloud-scale/help/domain-mappings/introduction/&#34; %}}custom domain URL{{%/link%}}. 

When your service is run, Catalyst spawns server instances for its execution as needed, and scales them up or down based on the traffic, ensuring minimal latency. You will be able to view the spawned instances for your service from the console when it is run, and perform activities such as deleting service instances. Catalyst also offers detailed reports, stats, and execution logs of all your AppSail services that were executed, which helps you make informed business decisions. 

&lt;br&gt;

This help document covers the entirety of deploying software services onto AppSail, directly or as container images through the console or CLI. It also includes {{%link href=&#34;/en/serverless/help/appsail/help-guides/introduction/&#34; %}}helpful guides{{%/link%}} for simple applications that you can build in various frameworks of each Catalyst-managed runtimes, along with sample code and the steps to associate them with AppSail. You can also find examples to {{%link href=&#34;/en/serverless/help/appsail/debug-appsail/&#34; %}}debug an AppSail service{{%/link%}} in different IDEs.


--------------------------------------------------------------------------------
title: "AppSail Basics"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.637Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/appsail-basics/"
service: "Serverless"
--------------------------------------------------------------------------------


### Comparing Catalyst Serverless Functions and AppSail Services

Both Catalyst Functions and AppSail are Serverless offerings that enable you to build the backend logic of your solution containing the main functionalities. 

Given below are some note-worthy points about the differences and similarities between Catalyst Serverless functions and AppSail services. You will need to understand these to ensure you use the right component for your needs.

&lt;br&gt;

&lt;table class=&#34;content-table&#34;&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;strong&gt;Catalyst Serverless Functions&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;AppSail Services&lt;/strong&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;

&lt;tbody&gt;

&lt;tr&gt;&lt;td&gt;Use Catalyst serverless functions to build backend logic for basic or elaborate HTTP operations, event-driven flows, scheduled job executions, or integrations.&lt;/td&gt;
&lt;td&gt;Use AppSail services to build and deploy independent web services for any requirements.&lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;Functions generally pack a tightly-coupled application logic that incorporate Catalyst components through language-specific SDKs.&lt;/td&gt;
&lt;td&gt;You can implement component SDKs in your AppSail applications as well. However, you will be required to manage the implementation on your own.&lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;Catalyst functions cannot work independently outside the Catalyst platform, as they implement predefined coding structures specific to Catalyst.&lt;/td&gt;
&lt;td&gt;AppSail services are independent entities that can be engineered in any way you require, without any Catalyst-specific restrictions on the format.&lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;Catalyst handles the implementation and maintenance of the dependencies that serverless functions are pre-engineered with. For example, the node modules that are included by default when you initialize a Node.js function are implemented by Catalyst.&lt;/td&gt;
&lt;td&gt;With AppSail, you must entirely handle all the implementation and maintenance of all frameworks, libraries, plugins, dependencies, and overheads that you might use in your code for all the supported platforms.   &lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;With Serverless functions, you incur costs when API calls are made to invoke function endpoints. The billing model works based on the number of API calls made to access a function endpoint.&lt;/td&gt;
&lt;td&gt;AppSail services incur costs based on the number of server instances that are actively running. In other words, you will be billed for instance uptime, and not for the number of requests made directly to access an app endpoint.  &lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;You will not be required to perform any infrastructure, backend, or platform management for serverless functions.&lt;/td&gt;
&lt;td&gt;You will not be able to perform any infrastructure management. However, you can manage the platform of your app instances after you deploy it.&lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;You can deploy multiple functions of any supported stack or type in a single project through Serverless functions.&lt;/td&gt;
&lt;td&gt;You can deploy multiple apps of any supported stack or custom stack in a single project through AppSail. &lt;/td&gt;&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;br&gt;


### Comparing Deployments of AppSail Services as Catalyst-Managed Runtimes vs Custom Runtime

The following table explains the differences between deploying AppSail services as {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtime{{%/link%}} and as {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/overview/&#34; %}}custom runtimes{{%/link%}}. After they are deployed on Catalyst, you can configure and manage all AppSail services and their platform in the same way, and obtain statistics and reports for all apps.

&lt;table class=&#34;content-table&#34;&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;strong&gt;Catalyst-Managed Runtimes&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;Custom Runtimes&lt;/strong&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;

&lt;tbody&gt;

&lt;tr&gt;&lt;td&gt;Deploy the build files of your application directly on AppSail. In this method, you only ship your code to Catalyst, and we handle its execution on a platform built for Catalyst-managed runtimes.&lt;/td&gt;
&lt;td&gt;Deploy a container image of your application to host it on Catalyst. You can deploy an image from your local registry, or one that is hosted on a supported container registry service.&lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;The runtime is completely managed by Catalyst. This means that you need not handle the runtime executable files or the stack dependencies for your app&#39;s execution. You will still need to manage the dependencies your app&#39;s codebase includes. &lt;/td&gt;
&lt;td&gt;You must manage all dependencies, including the runtime dependencies. You will need to install the binaries your application needs, and manage your runtime and OS dependencies by yourself.&lt;/td&gt;&lt;/tr&gt;

&lt;tr&gt;&lt;td&gt;You can only deploy web services that are of the natively supported runtimes of Java, Node, and Python by Catalyst.&lt;/td&gt;
&lt;td&gt;You can deploy web services of any programming environments and runtimes, such as Go or PHP, and even the runtimes of Java, Node.js, Python that are not natively supported by Catalyst.&lt;/td&gt;&lt;/tr&gt;

&lt;/tbody&gt;
&lt;/table&gt;

&lt;br&gt;

### AppSail Execution Basics

AppSail enables you to manage the execution platform of your app after its deployment. When your application is invoked, it would be running on one or many instances based on the number of requests being served. 

The logic of spawning service instances for an invoked application is explained below:

* When the first request is made to access an inactive application, AppSail has an initial cold start time to spawn a brand new server instance for it. This is a feature of serverless platforms, wherein instances are only generated on demand.

* The memory and disk size you configure for your app&#39;s execution are utilized after the app is invoked.

* When 80% of the request threshold of an active instance is utilized, AppSail will automatically scale up and spawn a new instance to serve new requests. When the load reduces, AppSail will scale down and kill excess instances.

* An app instance, when spawned, will be active for 5 minutes in total. Even if a single request is made to access the app, the instance will be active to serve it through its duration.

* You can perform a manual override to kill server instances in situations where your app experiences bugs or malfunctions, or is stuck in a deadlock. For example, an infinite loop bug.

You can also manage your app in other ways, such as temporarily disabling an app or permanently deleting it. Refer {{%link href=&#34;/en/serverless/help/appsail/console/overview/&#34; %}}to the console help section{{%/link%}} for details about deployment and execution logs, or the steps to manage your AppSail services.


#### Key Points to Remember

Catalyst observes certain restrictions for the AppSail services that you create, in terms of resources or instance executions. Given below are some of the key limitations that you must remember:

* You can only create 5 AppSail services in a single Catalyst project.

* Inactive app instances will be scaled down after 5 minutes of uptime*

* AppSail will only generate 5 instances for a single app in total*

* Catalyst can execute 100 requests concurrently per app instance.* 

* AppSail will scale and spawn a new instance when 80% of the request threshold of an active instance is utilized. That is, after an instance serves 80 requests concurrently, a new instance will be spawned.

* Your app will need to start listening in the listening port within 10 seconds. When no process in that port is found to be active within this duration, the user instance that will be created past the threshold will be killed, and the next request will trigger a new cold start instance.

* An app request needs to be completed in 30 seconds. Otherwise, the request will be timed out.


{{%note%}}{{%bold%}}Note:{{%/bold%}} For the limitations indicated with an {{%bold%}}\\*{{%/bold%}}, we can increase the defined limits on a case-by-case basis, based on your requirements. Please contact Catalyst support at {{%link href=&#34;mailto:support@zohocatalyst.com&#34; %}}{{%bold%}}support@zohocatalyst.com{{%/bold%}}{{%/link%}} with your specific requirements to make requests.{{%/note%}}

--------------------------------------------------------------------------------
title: "AppSail Configurations"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.645Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/appsail-configurations/"
service: "Serverless"
--------------------------------------------------------------------------------


# AppSail Configurations

### Startup Commands

You can configure startup commands for your AppSail services that specify starting up the app based on the programming stack, framework, application files, and the web server used. Essentially, this is the command that you would provide in your local environment to start up an application with your configured server. 

Startup commands can be configured while deploying the app from the CLI during the deployment, or directly in the console after the app is deployed in the cloud.

{{%note%}}{{%bold%}}Note:{{%/bold%}} Configuring startup commands are optional for apps deployed as custom runtimes. This is because, you can add the startup command directly in the OCI image&#39;s definition. However, you can still configure it after the app is deployed in the console and override the pre-defined command.{{%/note%}}

The startup command can be configured for an app in two ways:

* {{%bold%}}Apps deployed from the CLI:{{%/bold%}} Configure this in the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/badge%}}{{%/link%}} file for the key {{%badge%}}command{{%/badge%}}, if you {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} the app before {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail/&#34; %}}deploying{{%/link%}} it. If you do a standalone deploy, you can provide this as an input during the deploy process. You can still configure this directly in the console after deploying it.

* {{%bold%}}Apps deployed in the console:{{%/bold%}} {{%link href=&#34;/en/serverless/help/appsail/console/configurations/#startup-command&#34; %}}Configure this directly in the console. {{%/link%}}

&lt;br&gt;

#### Startup Commands for Catalyst-Managed Runtimes

{{%bold%}}Java{{%/bold%}}:

Java applications typically include embedded servers in the app&#39;s code, based on the framework used. For example, Spring Boot apps come bundled with web servers by default. However, certain frameworks or formats might not include servers by default, and you will need to configure an embedded server independently in your Java code. Some common web servers that are used are {{%link href=&#34;https://www.eclipse.org/jetty/&#34; %}}Eclipse Jetty{{%/link%}} or {{%link href=&#34;https://tomcat.apache.org/&#34; %}}Apache Tomcat{{%/link%}}.

{{%note%}}{{%bold%}}Note:{{%/bold%}} Catalyst supports two formats for Java applications: {{%bold%}}Java WAR{{%/bold%}} and {{%bold%}}Java SE{{%/bold%}}. When you initialize a Java app as a WAR file, you need not provide any embedded server for your app, as Catalyst bundles it with the Jetty server by default. You therefore need not provide any startup commands either. Catalyst will handle the application startup. However, you will need to embed a server if you select the Java SE  option and provide startup commands accordingly. You can go through the {{%link href=&#34;/en/serverless/help/appsail/help-guides/java/overview/&#34; %}}Java Help Guide{{%/link%}} for some examples.{{%/note%}}

{{%bold%}}Node.js and Python{{%/bold%}}: 

For Node.js and Python applications, depending on the frameworks you use, deployment servers might be included as a part of the framework. You will need to configure and manage application servers accordingly, and provide appropriate startup commands for your apps. Catalyst does not provide any built-in support for any servers for these programming environments. 

&lt;br&gt;

Certain frameworks expect the [HTTP listen port](#ports-for-app-executions) to be specified in the command line while starting the server.

For example:

{{%code class=&#34;language-json&#34;%}}python3 -m http.server ${X_ZOHO_CATALYST_LISTEN_PORT}{{%/code%}}

However, in AppSail, the startup commands are executed directly without any involving any shell operations. Therefore, when needed, you must specify the startup command to be executed as a shell command for any shell completions.

For example:

{{%code class=&#34;language-json&#34;%}}sh -c &#39;python3 -m http.server ${X_ZOHO_CATALYST_LISTEN_PORT}&#39;{{%/code%}}

&lt;br&gt;


### Environment Variables

Environment variables are declared outside of the main source code and can be referred to, when needed. Catalyst enables you to store and manage variables for both the {{%link href=&#34;/en/deployment-and-billing/environments/introduction/&#34; %}}development and production environments{{%/link%}}. Declare a single variable and configure values for both these environments. For example, if you need to declare an auth token variable that will hold different values in both environments, you can do so.

You can configure environment variables for Catalyst-managed runtime apps and for custom runtime apps. These will be pushed to the platform instance when your service is spawned, and they can be accessed with runtime-specific code.

{{%note%}}{{%bold%}}Note:{{%/bold%}} If you want to declare a production variable, you must have {{%link href=&#34;/en/deployment-and-billing/environments/deployment-types/&#34; %}}deployed your project to the Production environment{{%/link%}}. You will not be able to access production variables if your project is not deployed, or if the production environment is disabled.{{%/note%}}

AppSail allows you to configure environment variables in two ways:

* {{%bold%}}Apps deployed from the CLI:{{%/bold%}} Configure this in the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/badge%}}{{%/link%}} file for the key {{%badge%}}env_variables{{%/badge%}}, if you if you {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} the app before {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail/&#34; %}}deploying{{%/link%}} it. If you do a standalone deploy, configure this in the console. 

* {{%bold%}}Apps deployed in the console:{{%/bold%}} {{%link href=&#34;/en/serverless/help/appsail/console/configurations/#environment-variables&#34; %}}Configure this directly in the console. {{%/link%}}


#### Use an Environment Variable

After you create an environmental variable, you can call it in your app&#39;s code by its keyname in different ways in different programming environments. The syntax for each programming environment is given below:

* {{%bold%}}Java:{{%/bold%}}

{{%code class=&#34;language-json&#34;%}}System.getenv(variable_name){{%/code%}}

* {{%bold%}}Node.js:{{%/bold%}}

{{%code class=&#34;language-json&#34;%}}process.env.[variable_name]{{%/code%}}

* {{%bold%}}Python:{{%/bold%}}

{{%code class=&#34;language-json&#34;%}}os.getenv(variable_name){{%/code%}}

{{%badge%}}variable_name{{%/badge%}}: The keyname declared for the variable

{{%note%}}{{%bold%}}Note:{{%/bold%}} The variable&#39;s value is fetched based on the environment the app is invoked in. That is, if the {{%link href=&#34;/en/serverless/help/appsail/console/overview/#appsail-url&#34; %}}development URL of the app{{%/link%}} is invoked, the development value of the variable is fetched, and vice versa.{{%/note%}}

&lt;br&gt;

### Memory and Disk Allocation

You can allocate memory for your app&#39;s execution based on its load and performance requirements. If you do not specifically configure a memory for your app, the default memory of 512 MB will be allocated for its execution. You can also allocate the disk space needed for your app based on its size. The default storage allocated for your app will be 256 MB as well.

You can always edit and re-configure the memory and storage after you analyze your app&#39;s requirements based on its performance, and optimize it further. 

AppSail allows you to configure the memory in two ways:

* {{%bold%}}Apps deployed from the CLI:{{%/bold%}} Configure this in the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/badge%}}{{%/link%}} file for the key {{%badge%}}memory{{%/badge%}}, {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} the app before {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail/&#34; %}}deploying{{%/link%}} it. If you do a standalone deploy, configure this in the console. 

* {{%bold%}}Apps deployed in the console:{{%/bold%}} {{%link href=&#34;/en/serverless/help/appsail/console/configurations/#app-execution-settings&#34; %}}Configure this directly in the console. {{%/link%}}

&lt;br&gt;

### Ports for App Executions

AppSail listens through HTTP ports and grants network access in your application. That is, all the incoming connections to the app will be listened for through a specific port. You can configure the listening port in Catalyst by referring to the [environment variable](#environment-variables) key {{%badge%}}X_ZOHO_CATALYST_LISTEN_PORT{{%/badge%}} in your application code and connect to the Internet. Catalyst will check for the process listening on this port. 

Refer to the {{%link href=&#34;/en/serverless/help/appsail/help-guides/introduction/&#34; %}}Help Guide{{%/link%}} section for examples of configuring the AppSail listen port in your application&#39;s code. 

{{%note%}}{{%bold%}}Note:{{%/bold%}} You can assign a port you need for your AppSail service. Ports within the range of 0 to 1024 are reserved, with the exception of ports 80 and 443. You can use any port other than these. Port 9000 will be used by default.{{%/note%}}

Depending on the framework of your runtime, you might need to specify the HTTP listen port in your [startup command](#startup-commands) while starting the server.


--------------------------------------------------------------------------------
title: "Implement Catalyst SDK"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.651Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/implement-catalyst-sdk/"
service: "Serverless"
--------------------------------------------------------------------------------


# Implement Catalyst SDK in AppSail

Catalyst enables you to implement the SDK packages of the supported development environments in your AppSail applications for {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtimes{{%/link%}}. This enables you to avail other Catalyst services and components in your app&#39;s functionality. You can implement the development SDKs of various programming environments in your app as specified below.

{{%note%}}{{%bold%}}Note:{{%/bold%}} This is only available for web services built for a supported Catalyst-managed runtime. You will not be able to implement Catalyst SDK for apps deployed as OCI images through {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/overview/&#34; %}}custom runtime{{%/link%}}.{{%/note%}}

### Implement Catalyst Java SDK

You can download the Catalyst Java SDK package from the {{%link href=&#34;/en/getting-started/set-up-a-catalyst-project/developer-tools/&#34;%}}Developer Tools settings{{%/link%}} in your Catalyst console and include it in your app&#39;s source code. You can then implement the Catalyst Java SDK in your application&#39;s code and initialize it. Refer {{%link href=&#34;/en/sdk/java/v1/overview/&#34;%}}Catalyst Java SDK help{{%/link%}} for details about the various functionalities of the SDK toolkit and sample code snippets.

The steps to implement and initialize the Catalyst SDK for different API versions of Java servlets are demonstrated with sample codes below. 

In all cases, Catalyst requires you to implement the {{%badge%}}**AuthHeaderProvider**{{%/badge%}} interface from the Catalyst Java SDK package. The implementation defines the {{%badge%}}getHeader(){{%/badge%}} method that returns the value of the request header. You can then pass an object of the implementation class to the {{%badge%}}init(){{%/badge%}} method, to initialize the SDK.

#### Java Servlet API versions &lt;=4


Sample code for Java applications that use Java servlets of API versions lesser than or equal to 4.0 ({{%badge%}}{{%link href=&#34;https://docs.oracle.com/javaee%2F7%2Fapi%2F%2F/javax/servlet/package-summary.html&#34;%}}javax.servlet{{%/link%}}{{%/badge%}}):

**Implementation Class:**


{{%code class=&#34;language-java&#34;%}}package com.zoho.catalyst.appsail.demo.utils;
import javax.servlet.http.HttpServletRequest;
import com.zc.auth.AuthHeaderProvider;
public class AuthProviderImpl implements AuthHeaderProvider {
 HttpServletRequest request;
 public AuthProviderImpl(HttpServletRequest request) {
  this.request = request;
 }
 @Override
 public String getHeaderValue(String key) {
  return request.getHeader(key);
 }
}
{{%/code%}}

&lt;br&gt;

**Initialization:**

{{%code class=&#34;language-json&#34;%}}AuthProviderImpl authProviderImpl = new AuthProviderImpl(req);
CatalystSDK.init(authProviderImpl){{%/code%}}

&lt;br&gt;


#### Java Servlet API versions &gt;=5


Sample code for Java applications that use Java servlets of API versions greater than or equal to 5.0 ({{%badge%}}{{%link href=&#34;https://mvnrepository.com/artifact/jakarta.servlet&#34;%}}jakarta.servlet{{%/link%}}{{%/badge%}}):

**Implementation Class:**


{{%code class=&#34;language-java&#34;%}}import com.zc.auth.AuthHeaderProvider;
import jakarta.servlet.http.HttpServletRequest;
public class AuthProviderImpl implements AuthHeaderProvider {
    private HttpServletRequest request;
    AuthProviderImpl(HttpServletRequest request) {
        this.request = request;
    }
    @Override
    public String getHeaderValue(String s) {
        return request.getHeader(s);
    }
}{{%/code%}}

&lt;br&gt;

**Initialization:**

{{%code class=&#34;language-json&#34;%}}CatalystSDK.init(new AuthProviderImpl((HttpServletRequest) servletRequest));{{%/code%}}

&lt;br&gt;

If you are developing a Java application with the {{%link href=&#34;https://maven.apache.org/&#34;%}}Maven{{%/link%}} build tool, you can include the Catalyst Java SDK as a dependency in the Maven configuration file ({{%link href=&#34;https://maven.apache.org/guides/introduction/introduction-to-the-pom.html&#34;%}}{{%badge%}}pom.xml{{%/badge%}}{{%/link%}}), instead of downloading and adding the SDK in your source code manually. 

To add the Catalyst SDK in a Maven project, simply add the Zoho repository (published in {{%link href=&#34;https://mvnrepository.com/&#34;%}}MvnRepository{{%/link%}}) in the {{%badge%}}pom.xml{{%/badge%}} file as shown below:


{{%code class=&#34;language-json&#34;%}}&amp;lt;repositories&amp;gt;
	&amp;lt;repository&amp;gt;
      &amp;lt;id&amp;gt;java-sdk&amp;lt;/id&amp;gt;
      &amp;lt;url&amp;gt;https://maven.zohodl.com&amp;lt;/url&amp;gt;
    &amp;lt;/repository&amp;gt;
  &amp;lt;/repositories&amp;gt;{{%/code%}}

You can then add the Java SDK as a dependency in pom.xml as shown below:
{{%code class=&#34;language-json&#34;%}}&amp;lt;dependencies&amp;gt;
    &amp;lt;dependency&amp;gt;
      &amp;lt;groupId&amp;gt;com.zoho.catalyst&amp;lt;/groupId&amp;gt;
      &amp;lt;artifactId&amp;gt;java-sdk&amp;lt;/artifactId&amp;gt;
      &amp;lt;version&amp;gt;1.15.0&amp;lt;/version&amp;gt;
    &amp;lt;/dependency&amp;gt;
 &amp;lt;/dependencies&amp;gt;{{%/code%}}

&lt;br&gt;

### Implement Catalyst Node.js SDK

You can install the Catalyst Node.js SDK package by executing the following command in your terminal and including it in your app&#39;s source code:

{{%code class=&#34;language-json&#34;%}}npm install zcatalyst-sdk-node --save{{%/code%}}

This will install the latest supported version of the Node.js SDK. You can also install a specific supported version in this way:

{{%code class=&#34;language-json&#34;%}}npm install zcatalyst-sdk-node@2.1.1 --save{{%/code%}}

You can then initialize the Node.js SDK in your application&#39;s code as shown in the sample code below. This passes the request object to the {{%badge%}}initialize(){{%/badge%}} method.

{{%code class=&#34;language-javascript&#34;%}}const catalyst = require(&#39;zcatalyst-sdk-node&#39;)
const express = require(&#39;express&#39;)
const app = express()
app.get((req, res) =&gt; {
let catalystApp = catalyst.initialize(req);
//Your code goes here 
})
app.listen(process.env(&#34;X_ZOHO_CATALYST_LISTEN_PORT&#34;) || 9000){{%/code%}}


Refer {{%link href=&#34;/en/sdk/nodejs/v2/overview/&#34;%}}Catalyst Node.js SDK help{{%/link%}} for details. The SDK documentation also provides sample code snippets for all supported functionalities.

&lt;br&gt;

### Implement Catalyst Python SDK

You can install Catalyst Python SDK for your AppSail solution by executing the following command in your terminal and including it in your app&#39;s source code:

{{%code class=&#34;language-json&#34;%}}pip install zcatalyst-sdk -t .{{%/code%}}

You can then import the Python SDK in your code for your Catalyst app. The SDK will need to be initialized with the request object before each request. 

An example code snippet for importing and initializing Python SDK in a Flask web app is shown below:

{{%code class=&#34;language-python&#34;%}}from flask import Flask, request, g
import os
import zcatalyst_sdk
from zcatalyst_sdk.catalyst_app import CatalystApp
app = Flask(__name__)
@app.before_request
def before_request():
    if request.path.startswith(&#39;/admin&#39;):
        return &#39;Unauthorized&#39;, 401
    # if authorized user
    g.zc_app = zcatalyst_sdk.initialize(req=request)
@app.route(&#39;/&#39;)
def index():
    return &#39;Web App with Python Flask!&#39;
@app.route(&#39;/cache&#39;)
def cache():
    app: CatalystApp = g.zc_app
    resp = app.cache().segment().put(&#39;key&#39;, &#39;value&#39;)
    return resp, 200
listen_port = os.getenv(&#39;X_ZOHO_CATALYST_LISTEN_PORT&#39;, 9000)
app.run(host=&#39;0.0.0.0&#39;, port = listen_port){{%/code%}}


Refer to {{%link href=&#34;/en/sdk/python/v1/overview/&#34;%}}Catalyst Python SDK help{{%/link%}} for details about the various functionalities of the SDK toolkit and sample code snippets.

--------------------------------------------------------------------------------
title: "Debug AppSail Services"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.651Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/debug-appsail/"
service: "Serverless"
--------------------------------------------------------------------------------


# Debug AppSail Services

This section contains examples to debug sample AppSail services built on specific frameworks of {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtimes{{%/link%}} on popular IDEs. Depending on the programming environment and  the framework, appropriate IDEs are used to demonstrate the steps.

## Java

### Debug a Spring MVC application in Visual Studio Code

Follow the steps provided in this section to debug and test a Java application built on the {{%link href=&#34;https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/mvc.html&#34; %}}Spring MVC framework{{%/link%}} in the {{%link href=&#34;https://code.visualstudio.com/&#34; %}}Visual Studio Code{{%/link%}} environment. 

**Prerequisites:** A Spring MVC application created and available in VSCode

1. Open the Spring application project in your VSCode IDE.

2. Install the following extension in your VSCode: {{%link href=&#34;https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-debug&#34; %}}Debugger for Java{{%/link%}}. 


3. After the extension is installed, click on {{%bold%}}Run{{%/bold%}}, then {{%bold%}}Add Configuration...{{%/bold%}} Select {{%bold%}}Java{{%/bold%}} from the tool bar.


This will open the {{%badge%}}launch.json{{%/badge%}} file. 

4. Now click on {{%bold%}}Add Configuration...{{%/bold%}} shown in the file and select the {{%bold%}}Java: Attach to Remote Program{{%/bold%}} option.


5. Update the value of the &#34;{{%bold%}}hostName{{%/bold%}}&#34; key as &#34;{{%bold%}}localhost{{%/bold%}}&#34;. Then update the value of the &#34;{{%bold%}}port{{%/bold%}}&#34; key as &#34;{{%bold%}}5005{{%/bold%}}&#34;.


6. Now navigate to {{%bold%}}Run{{%/bold%}} from the toolbar and click {{%bold%}}Start Debugging{{%/bold%}} to debug your application.


&lt;br&gt;

### Debug a Spring MVC application in IntelliJ IDEA


Follow the steps provided in this section to debug and test a Java application built on the {{%link href=&#34;https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/mvc.html&#34; %}}Spring MVC framework{{%/link%}} in the {{%link href=&#34;https://www.jetbrains.com/idea/&#34; %}}IntelliJ IDEA environment{{%/link%}}.

**Prerequisites:** A Spring MVC application created and available in IntelliJ IDEA

1. Open the Spring application project in your IntelliJ IDEA.

2. Run the Spring application using the following command in the IDE&#39;s terminal:

{{%code class=&#34;language-java&#34;%}}mvn spring-boot:run -Dspring-boot.run.jvmArguments=&#34;-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005&#34; {{%/code%}}

3. Right click on the {{%bold%}}Run{{%/bold%}} option in the toolbar and click {{%bold%}}Debug{{%/bold%}}.


4. Now either click {{%bold%}}Edit Configurations{{%/bold%}} and click on the {{%bold%}}\&#43; {{%/bold%}} icon to create a new configuration, or click {{%bold%}}Add New Configuration{{%/bold%}} and click {{%bold%}}Remote JVM Debug{{%/bold%}}.


5. You can change the port number as per your requirements. In this example, we will port &#34;{{%bold%}}5005{{%/bold%}}&#34;. Now verify that the &#34;{{%bold%}}Use module classpath{{%/bold%}}&#34; points to your Spring application, then click {{%bold%}}Debug{{%/bold%}}.
 
 
6. Verify if the Debug Console displays the following: &#34;{{%bold%}}Connected to the target VM, address: &#39;localhost:5005&#39;, transport: &#39;socket&#39;{{%/bold%}}&#34;


{{%note%}}{{%bold%}}Note:{{%/bold%}} Ensure that the &#34;{{%bold%}}Mute Breakpoints{{%/bold%}}&#34; are not enabled.{{%/note%}}

7. You can now create breakpoints in your Spring application and start debugging it. 


## AppSail in the Console


--------------------------------------------------------------------------------
title: "Overview"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.652Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/console/overview/"
service: "Serverless"
--------------------------------------------------------------------------------


# AppSail in the Console

## The Overview Section

The *Overview* tab contains the general details of the app service, the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}deployment URL{{%/link%}}, and a live dashboard of the instances that are actively running.

&lt;br /&gt;

These include the details of the {{%link href=&#34;/en/getting-started/set-up-a-catalyst-project/collaborators/&#34; %}}admin or collaborator{{%/link%}} that deployed the app, the date and time of the app&#39;s creation and last deployment, and a **unique AppSail ID** created for your app automatically after you deploy it. 

This will also specify if the app is a Catalyst-managed runtime or a custom runtime, and if the source is the CLI, console, or a container registry service. You can find the Image Path or URL of the image from its container registry service, in the last case.

### AppSail URL

After your AppSail service is deployed, Catalyst hosts your app on a sub-domain with which you can access it. You can access the various endpoints that you configure in your app from this base URL.

The default base URL of your AppSail service will be of this format for development environment:

{{% code class=&#34;language-json&#34; %}}https://appsailservicename-ZAID.development.catalystappsail.com{{%/code%}}

For example:

{{% code class=&#34;language-json&#34; %}}https://demoservice-1011034735.development.catalystappsail.com{{%/code%}}

This will be the format for the production environment:

{{% code class=&#34;language-json&#34; %}}https://appsailservicename-ZAID.catalystappsail.com{{%/code%}}

* **AppSail service name:**  The name you provide while initializing or deploying the app

* **ZAID:** The unique identifier that maps an application to a project

{{%note%}}{{%bold%}}Note:{{%/bold%}} The &#34;development&#34; indicates the development environment of your project. After you {{%link href=&#34;/en/deployment-and-billing/environments/introduction/&#34; %}}deploy your project to production{{%/link %}}, the URL will not include that key.{{%/note%}}


#### Custom AppSail URL

Catalyst provides you with the convenience of editing the AppSail service name and ZAID part of the URL, and adding any sub-domain name of your choice for the AppSail URL. The &#34;catalystappsail&#34; domain will remain the same in this method, along with the &#34;development&#34; key for the apps in the development environment. 

1. You can edit the AppSail URL by clicking the **Edit AppSail URL** from the Overview section.

&lt;br /&gt;

2. Enter the sub-domain name that you require, then click **Update**.

&lt;br /&gt;

&lt;br&gt;

### Live dashboard 

The dashboard displays every currently running instance of the app after it is invoked. 

&lt;br /&gt;

AppSail spawns a new instance for your app after a running instance is almost entirely consumed. You will be able to see the percentage of consumption of each instance, and details such as the unique {{%bold%}}Instance ID{{%/bold%}} and the duration it has been running for.

You can click {{%bold%}}Refresh{{%/bold%}} to get an updated status of the active instances, in case there are lags.

&lt;br /&gt;

### Delete an Active Instance

You can manually delete an active instance if you require, in cases when you experience a bug or a deadlock situation, such as an infinite loop bug. 

1. Click the ellipsis icon for an instance, then click **Delete**.

&lt;br&gt;

2. Click **Yes, Proceed** in the confirmation pop-up.

&lt;br&gt;


--------------------------------------------------------------------------------
title: "Instances"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.652Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/console/instances/"
service: "Serverless"
--------------------------------------------------------------------------------


# The Instances Section

The Instances section provides valuable insights about the instances that were executed in the form of simple graphs, the execution history details, as well as execution logs. 

### Analytics

&lt;br /&gt;

In the **Analytics** section, you can select a duration for the stats you would like to see using the duration drop-down. The graphs will be refreshed to depict stats accordingly.

&lt;br /&gt;

The graphs in this section include:

* **Max Instances and No. of Requests vs Time:** Depicts the maximum number of instances that were spawned in parallel and the number of requests that were served with these instances through the line graph at specific points of time. Based on the duration you select, the time intervals will vary in the graph.

* **Total Instances and Run Duration vs Time:**  Depicts the total number of instances that were active and the total duration of the execution of all instances through the line graph at specific points of time. Based on the duration you select, the time intervals will vary in the graph.

You can hover over any part of the graphs to see details.


### History

Click the **History** tab to view the execution history of your app.

&lt;br /&gt;

You can select a duration for the logs you would like to see through the duration drop-down on the right hand side. The execution logs will be refreshed accordingly.

&lt;br /&gt;

The details shown here include the total number of instances run, then the Instance ID, start date and time, end date and time, and the duration of each instance execution. 

You can also filter the results by clicking the **Filter** button. Click **Search by ID** to filter by Instance ID. You can also select the Duration box, then select a comparison type and pick hours and minutes from the drop-downs to find matches accordingly.

&lt;br /&gt;

Click **Apply** after you configure the filters to view results.

Additionally, you can access the **execution logs** of each instance by clicking the respective logs icon. This will redirect you to {{%link href=&#34;/en/devops/help/logs/introduction/&#34; %}}Catalyst Logs{{%/link%}} in the DevOps service. The filters for the logs come automatically applied.

&lt;br /&gt;

--------------------------------------------------------------------------------
title: "Deployments"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.653Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/console/deployments/"
service: "Serverless"
--------------------------------------------------------------------------------


# Deployments

The Deployments section displays all the deployments of the specific AppSail service, along with its deployment details, and links to the deployment logs as applicable.

&lt;br /&gt;

You can view details such as the source of a particular deployment, the {{%link href=&#34;/en/getting-started/set-up-a-catalyst-project/collaborators/&#34; %}}admin or collaborator{{%/link%}} that deployed it, the date and time of deployment, and the status. 

{{%note%}}{{%bold%}}Note:{{%/bold%}} When you create a new deployment for an existing AppSail service, you can deploy the app from the CLI, the console, or from a container-registry service, essentially changing the type of app as a Catalyst-managed runtime or a custom runtime as you prefer. An individual AppSail service is not tied to one of these types, as the type and source can be different for each of its deployments. {{%/note%}}

Because each deployment is different, the Deployments section will mention if a particular deployment is a Catalyst-managed runtime or a custom runtime, and if the source is the CLI, console, or a container registry service. You can find the Image Path or URL of the image from its container registry service, in the last case.

### Deployment Logs

The Deployment logs are available only for container images deployed directly from the container registry service. To view the log of a particular deployment, click the logs icon shown for it. 

&lt;br /&gt;

#### Create a New Deployment

You can create a new deployment for an existing AppSail service from the Deployments section, by clicking the **Create Deployment** button on the top-right corner. This will initiate the process of deploying the app from the console for {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34;%}}Catalyst-managed runtime{{%/link%}} or a {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34;%}}custom runtime{{%/link%}}, and the steps will be the same. 

As mentioned earlier, you have the flexibility to change the source and the type of app (Catalyst-managed runtime or custom runtime) from its previous deployments by clicking **Edit** for the source.


--------------------------------------------------------------------------------
title: "Configurations"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.653Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/console/configurations/"
service: "Serverless"
--------------------------------------------------------------------------------


# The Configuration Section

The *Configuration* section enables you to perform configurations for your AppSail services from the console. These configurations can be done through the {{%badge%}}{{%link href=&#34;/en/serverless/help/appsail/key-concepts/catalyst-configurations/#the-app-configjson-file&#34;%}}app-config.json{{%/link%}}{{%/badge%}} file of your app for the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34;%}}Catalyst-managed runtime{{%/link%}} apps and then be deployed, or directly during deploying the app from the console for Catalyst-managed or {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/container-registry-services/&#34;%}}custom runtimes{{%/link%}}. You could also configure the startup command in a container image depending on its setup for the apps deployed as a container image. 

{{%note%}}{{%bold%}}Note:{{%/bold%}} All configurations you do in the {{%badge%}}app-config.json{{%/badge%}} file, in the console, or in your container image will be reflected in this section in the console after you deploy your app. If you choose to edit the configurations from this section, that will override the configurations in your code or binaries.{{%/note%}}

&lt;br /&gt;

The steps to configure these values from the console are explained below.

### Environmental Variables

You can create and store {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#environmental-variables&#34;%}}environmental variables{{%/link%}} as key-value pairs for your app outside of the main code, for both the {{%link href=&#34;/en/deployment-and-billing/environments/introduction/&#34;%}}development and production environments{{%/link%}}. 

To create a new environmental variable:

1. Click **Create Variable** in the *Environmental Variables* section.

&lt;br /&gt;

2. Enter the keyname and value of the variable. If you&#39;re working from the development environment, the value you enter will be the development value, and vice-versa.


&lt;br /&gt;

3. Click **Save**.

The variable will be saved and listed in the section. You can search for variables by their keyname from the search bar, or add more variables.

&lt;br /&gt;

If you&#39;re working from the development environment, the development value is shown. If you switch to production environment, you can configure and view production values.

{{%note%}}{{%bold%}}Note:{{%/bold%}} You will be able to add Production variables only if your app has been deployed to production previously.{{%/note%}}

&lt;br&gt;

You can click the **Usage Syntax** button to check the syntax for each programming environment. This is explained in {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#use-an-environmental-variable&#34;%}}this section{{%/link%}}.

&lt;br /&gt;


#### Edit an Environmental Variable

You can edit an environment variable&#39;s development or production values from that environment in the following way:

1. Click the ellipsis icon for the variable, then click **Edit**.

&lt;br /&gt;

3. Edit the values, then click **Save**.

&lt;br /&gt;


#### Delete an Environmental Variable

You can delete the development or the production value of an environment variable from that environment. When you delete it from one environment, the value in the other environment is still available.

To delete an environmental variable:

1. Click the ellipsis icon for the variable, then click **Delete**.

&lt;br /&gt;

3. Click **Yes, Proceed** to confirm.

&lt;br /&gt;

&lt;br&gt;

### Startup Command

You can configure the startup command for your app, or edit the command already present, from this section. Refer to the {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34;%}}Startup Command section{{%/link%}} for details about this.

To configure or edit a startup command for your app:

1. Click the **Edit** button in the *Startup Command* section.

&lt;br /&gt;

2. Enter the startup command, then click **Update**.

&lt;br /&gt;

&lt;br&gt;

### App Execution Settings

You can allocate the {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#memory-and-disk-allocation&#34;%}}memory and disk size{{%/link%}} for your AppSail&#39;s execution based on its performance requirements in this section. You can also configure the {{%link href=&#34;3/en/serverless/help/appsail/appsail-configurations/#ports-for-app-executions&#34;%}}port{{%/link%}} for your app&#39;s execution here. Refer to the links for details.

{{%note%}}{{%bold%}}Note:{{%/bold%}} &lt;br&gt;

* The memory can be configured in the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34;%}}{{%badge%}}app-config.json{{%/badge%}}{{%/link%}} file for a Catalyst-managed runtime app while initializing or adding it from the CLI. 
* Catalyst assigns 256 MB for the disk size and 512 MB for the memory by default.
* Configuring the port for a custom-runtime app is optional, as it can be configured while defining the container image as well. The values configured here will override these internal configurations.{{%/note%}}


To configure the memory, disk size, and port for an AppSail service:

1. Navigate to the **App Execution Settings** tab, then click **Edit**.

&lt;br /&gt;

2. Select the required memory and disk size for the app from the drop-down. Enter the port for the AppSail service. Click **Save**  after configuring these details.

&lt;br /&gt;

{{%note%}}{{%bold%}}Note:{{%/bold%}} You can assign a port you need for your AppSail service. Ports within the range of 0 to 1024 are reserved, with the exception of ports 80 and 443. You can use any port other than these. Port 9000 will be used by default. If you have not configured the port in your code, ensure that you configure the same port to listen to while starting the server in the startup command of your app.{{%/note%}}

--------------------------------------------------------------------------------
title: "Manage AppSail"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.653Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/console/manage-appsail/"
service: "Serverless"
--------------------------------------------------------------------------------


# Manage AppSail

### Disable an App

You can temporarily disable an AppSail service, if required. When an app is disabled, it cannot be invoked through its development or production {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34;%}}deployment URL{{%/link%}} until you enable it again.

{{%note%}}{{%bold%}}Note:{{%/bold%}} You can still create or modify configurations for the app, or deploy changes from your local environment even when the app is disabled.{{%/note%}}

To disable an app in AppSail:

1. Click the ellipsis icon for an app from the AppSail index page, then click **Disable**.

&lt;br /&gt;

2. Enter &#34;DISABLE&#34; in the pop-up to confirm, then click **Confirm**.

&lt;br /&gt;

This will change the status of the app to &#34;Inactive&#34; in the index page. 

&lt;br&gt;

#### Enable the App 

You can enable a disabled app again by navigating to the index page. 

1. Click the ellipsis icon, and then click **Enable**.

&lt;br /&gt;

2. Click **Yes, Proceed** to confirm.

&lt;br /&gt;

&lt;br&gt;

### Delete an App

You can permanently delete an AppSail app from the remote console. This will remove the app from being hosted in AppSail. 

To delete an app in AppSail:

1. Navigate to the AppSail&#39;s index page. Then, click the ellipsis icon for the app, and click **Delete**.

&lt;br /&gt;

2. Enter &#34;DELETE&#34; in the pop-up to confirm, then click **Confirm**.

&lt;br /&gt;

You will need to deploy the app again after it is deleted, if you require it.

&lt;br&gt;

### Download an App&#39;s Code

Catalyst enables you to download the source code of a deployed AppSail service from the console to your local system for **Catalyst-managed runtime apps only**. This will download a ZIP file of the entire directory that was deployed to the console, which includes the application files and any configuration files that were bundled and uploaded. This is not available for a custom runtime app.

You can download an AppSail app&#39;s source code by clicking the ellipsis icon of an app from the AppSail index page, then clicking **Download**.

&lt;br /&gt;


## Catalyst-Managed Runtimes


--------------------------------------------------------------------------------
title: "Key Concepts"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.654Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/"
service: "Serverless"
--------------------------------------------------------------------------------


# Catalyst-Managed Runtimes

## Key Concepts

### Overview

You can deploy an application as a Catalyst-managed runtime if its stack is one of the supported runtimes. You can develop this web service using any frameworks, libraries, plugins, or dependencies as needed. As the term suggests, it is only the runtime that is managed by Catalyst. You will still need to manage the dependencies your code includes. You can directly deploy the build files of your application, either through the CLI or from the console.

Catalyst currently manages the following runtimes: 

* {{%bold%}}Java{{%/bold%}}: Java 8, Java 11, Java 17 in the Java SE and Java WAR formats
* {{%bold%}}Node.js{{%/bold%}}: Node 16, Node 18, Node 20
* {{%bold%}}Python{{%/bold%}}: Python 3.9

Although AppSail does not include many Catalyst-specific configurations or format restrictions, there are certain definitions that are bundled with your app that contain information about hosting and executing the app. These are discussed below.

&lt;br&gt;

### The app-config.json File

When you {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} an AppSail service as a Catalyst-managed runtime from the CLI, Catalyst creates a configuration file app-config.json and includes your app configuration in it. This file is created in the directory you initialize the app in, otherwise called the [source directory](#source-directory-and-build-path). 

{{%note%}}{{%bold%}}Note:{{%/bold%}} The {{%badge%}}app-config.json{{%/badge%}} file is not created when you do a {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail/&#34; %}}standalone deploy{{%/link%}} without initializing or adding the app first. The configuration that this file carries is directly fetched as input from you in the CLI during the deployment. This file is also not created for apps initialized as a custom runtime.{{%/note%}}

A sample {{%badge%}}app-config.json{{%/badge%}} created for a Java app is shown below:

{{%code class=&#34;language-json&#34;%}}{
	&#34;command&#34;: &#34;java -jar demo-0.0.1-SNAPSHOT.jar&#34;,
	&#34;buildPath&#34;: &#34;/Users/emma-426/CatalystDirectories/DemoApp&#34;,
	&#34;stack&#34;: &#34;java8&#34;,
	&#34;env_variables&#34;: {
		&#34;clientid&#34;:xxxxxxx,
         &#34;clientsecret&#34;:xxxxxx
         },
	&#34;memory&#34;: 256,
	&#34;platform&#34;: &#34;javase&#34;
	&#34;scripts&#34;: {
		&#34;preserve&#34;: &#34;mvn install -DskipTests&#34;
		&#34;predeploy&#34;: &#34;mvn install -DskipTests&#34;
	}
}{{%/code%}}

* {{%badge%}}command{{%/badge%}}: The {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34; %}}startup command{{%/link%}} for your app
* {{%badge%}}buildPath{{%/badge%}}: The directory that contains the [build files](#common-build-files) of your app
* {{%badge%}}stack{{%/badge%}}: The Catalyst-managed runtime of your app
* {{%badge%}}env_variables{{%/badge%}}: The {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#environment-variables&#34; %}}environment variables{{%/link%}} for your app
* {{%badge%}}memory{{%/badge%}}: The {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#memory-and-disk-allocation&#34; %}}memory{{%/link%}} allocated for your app&#39;s execution
* {{%badge%}}platform{{%/badge%}}: Defines if your app is of the {{%badge%}}javase{{%/badge%}} or {{%badge%}}javawar{{%/badge%}} format, applicable only to the Java stack
* {{%badge%}}scripts{{%/badge%}}: The {{%link href=&#34;/en/cli/v1/scripts/introduction/&#34; %}}scripts{{%/link%}} that can be executed before serving or deploying your app through {{%badge%}}preserve{{%/badge%}} and {{%badge%}}predeploy{{%/badge%}}

The values for the parameters {{%badge%}}stack{{%/badge%}}, {{%badge%}}buildPath{{%/badge%}}, and {{%badge%}}platform{{%/badge%}} are fetched mandatorily while initializing or adding the app. You can configure the other values in this file before deploying your app to the cloud. You can also {{%link href=&#34;/en/serverless/help/appsail/console/overview/&#34; %}}configure{{%/link%}} the environment variables, memory, and the startup command directly in the console after the deployment.

&lt;br&gt;

### Source Directory and Build Path

* By default, the source directory of your application is the directory that you execute the app {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} command from. You can also select another directory besides the current directory to be the source during the initialization. 

* You must add the source files of your app to the source directory. 

* The {{%badge%}}[app-config.json](#the-app-configjson-file){{%/badge%}} file gets created in the source directory of your app.

* The target directory is the directory that will contain the build files of your deployable web service. 

* You can specify the target directory of your app when you initialize or add the app, or add it for the parameter {{%badge%}}build-path{{%/badge%}} in the {{%badge%}}app-config.json{{%/badge%}} file. 

* When you do a standalone deploy, the current directory will be the build directory.

* You need not bundle or zip all the build files together, as AppSail will automatically bundle them during the application serve or deployment from the {{%badge%}}build-path{{%/badge%}} specified.

* You can name the main file of your app&#39;s build anything you prefer. However, when you build your app as a Java WAR file, you will need to name the main file {{%badge%}}root.war{{%/badge%}}. This is to ensure further configurations are prevented from your end when the endpoint URL is generated for your application. If you name your WAR file anything else, you will need to add some necessary controllers in your code accordingly.

&lt;br&gt;

### Common Build Files 

For Catalyst-Managed runtimes, based on the runtime and framework, your compiled or deployable code could be of any format in any structure. Some common formats are mentioned below:

* {{%bold%}}Java{{%/bold%}}: The final build file of a Java WAR app is of the {{%badge%}}.war{{%/badge%}} format. A WAR file is essentially a standard deployable format that can be readily run on any application server. It is a container for JAR files, JavaServer Pages, Java Servlets, Java classes, XML files, HTML, CSS etc of the application&#39;s source.

	If your build files are of any other format besides a *.war* file, you can select the Java SE template. Some other formats include {{%badge%}}.jar{{%/badge%}} or compiled class files, {{%badge%}}.class{{%/badge%}}. If you use any Java frameworks or libraries, you must include those files in the build path.

* {{%bold%}}Node.js{{%/bold%}}: The main deployable file is typically a {{%badge%}}.js{{%/badge%}} file. Based on the standards of the framework or the dependencies you add, there will be node modules and configuration files included in your app&#39;s directory. You must ensure that you add all node modules and configuration files, along with the main file and native client files in the build path.

* {{%bold%}}Python{{%/bold%}}: The deployable main file is typically a {{%badge%}}.py{{%/badge%}} file. Based on the standards of the framework, plugins, or dependencies you add, there will be Python and configuration files included in your app&#39;s directory. You must ensure that you add all modules and configuration files, along with the main file and native client files in the build path.


You can refer to the {{%link href=&#34;/en/serverless/help/appsail/help-guides/introduction/&#34; %}}Help Guide on building sample apps{{%/link%}} on building sample apps to learn more about using popular frameworks in each stack and deploying them as AppSail services.


--------------------------------------------------------------------------------
title: "Deploy from the CLI"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.654Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/catalyst-managed-runtimes/deploy-from-cli/"
service: "Serverless"
--------------------------------------------------------------------------------


# Deploy AppSail as a Catalyst-Managed Runtime from the CLI

### Initialize or Add an AppSail Service


You can {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} for a Catalyst-managed runtime directly in your app&#39;s directory, or from a new directory using the {{%link href=&#34;/en/cli/v1/cli-command-reference/&#34; %}}Catalyst CLI{{%/link%}}. You can also {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add an AppSail service{{%/link%}} to an existing Catalyst project directory, where other resources have been initialized. You can [deploy the AppSail service](#deploy-an-appsail-service) after you initialize or add it.

Catalyst creates an {{%bold%}}{{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/link%}}{{%/badge%}}{{%/bold%}} file when an AppSail service is initialized in this method.

To initialize an AppSail service in a new directory, create a folder for your project in your local machine and navigate to it from your terminal. Initialize a project by executing the following command from that directory:

{{%cli%}}catalyst init{{%/cli%}}

You can add an AppSail service in an existing Catalyst project directory by executing this CLI command:

{{%cli%}}catalyst appsail:add{{%/cli%}}

The steps to initialize or add the AppSail service will be the same as described below:

1. The CLI will prompt you to select the runtime type as **Catalyst-Managed Runtime** or **Docker Image** when AppSail is initialized or added. Select the first option.


2. You can now choose to get started with a readymade sample project by entering &#34;Y&#34; and pressing **Enter**, then selecting a sample app from the list. 


The sample app will be downloaded to the directory. Provide a name for it when prompted.


If you want to initialize your own app, enter &#34;N&#34; , then press **Enter**.

3. Select if this will be your {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#source-directory-and-build-path&#34; %}}source directory{{%/link%}} of your app by entering &#34;Y&#34;. If you enter &#34;N&#34;, the CLI will prompt you to type in the absolute path for your app&#39;s source in your directory. Press **Enter** after the entries.


4. Enter a name for your app. You can name the main file of your app&#39;s build anything you prefer.


{{%note%}}{{%bold%}}Note:{{%/bold%}} When you build your app as a Java WAR file, you will need to name the main file {{%badge%}}root.war{{%/badge%}} or add specific controllers according to your code.{{%/note%}}

5. Enter the absolute {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#source-directory-and-build-path&#34; %}}build path{{%/link%}} for your app, then press **Enter**.


6. Select a stack and runtime for your app and press **Enter**.


If you select Java, the CLI will further prompt you to pick either Java SE or the Java WAR as your app&#39;s deployable format. You can learn more about this {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}here{{%/link%}}.


If you select any other stack, this will be skipped.

AppSail is now initialized or added in the source directory you selected, and the app is now associated with the Catalyst project. The configurations will be updated in {{%link href=&#34;/en/cli/v1/project-directory-structure/catalyst-json/&#34; %}}{{%badge%}}catalyst.json{{%/badge%}}{{%/link%}} file accordingly.


This process will only create the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/link%}}{{%/badge%}} configuration file that is specific to AppSail in your app&#39;s source directory. You can edit the values such as the startup command, environment variables, or memory in this file before deploying.


&lt;br&gt;

### Deploy an AppSail Service

Catalyst enables you to deploy {{%link href=&#34;/en/serverless/help/appsail/introduction/&#34; %}}AppSail services{{%/link%}} in two different ways:

* {{%bold%}}Regular Deploy:{{%/bold%}} The regular deploy execution applies when you have already initialized an AppSail resource either during the {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}project initialization{{%/link%}} or by {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}adding it in an existing project directory{{%/link%}}. 

* {{%bold%}}Standalone Deploy:{{%/bold%}} You can do a standalone deploy of an app directly without initializing it as an AppSail service in prior. 

Catalyst will deploy all the executable files of your app present in the build path that you specified during the app initialization, in this case along with project configurations. 

{{%note%}}{{%bold%}}Note:{{%/bold%}} You need not bundle or zip all the build files together, as AppSail will automatically bundle them during the application serve or deployment from the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#source-directory-and-build-path&#34; %}}build path{{%/link%}} specified.{{%/note%}}

&lt;br&gt;

### Regular Deploy

If the AppSail app is already initialized in the project directory, the CLI will automatically deploy the app with the rest of the project resources when you execute the {{%badge%}}catalyst deploy{{%/badge%}} command. The CLI will display the endpoint URL of the app after it is deployed, that you can open it with.

&lt;br&gt;

If you have multiple AppSail apps in your project directory, you can access all of their URL endpoints from the CLI.

You can also execute the following command to deploy the AppSail service alone from your app&#39;s source directory.

{{%cli%}}catalyst deploy appsail{{%/cli%}}

The deployment process is the same.

&lt;br&gt;
 
&lt;br&gt;

### Standalone Deploy

You must execute the standalone deploy command from a Catalyst project directory&#39;s root. That is, {{%badge%}}catalyst.json{{%/badge%}} and other {{%link href=&#34;/en/cli/v1/project-directory-structure/introduction/&#34; %}}project dependency files{{%/link%}} must be present in the directory.

{{%note%}}{{%bold%}}Note:{{%/bold%}} If you execute the standalone deploy command without any of the [options specific to deploying container images](#standalone-deploy-appsail-options), the CLI will prompt you for inputs related to Catalyst-managed runtime apps only by default. {{%/note%}}

You must remember the following points about the standalone deployment:

* You must ensure your app&#39;s deployable build files are present in the directory you execute the command from. This is because that directory will be considered the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#source-directory-and-build-path&#34; %}}build directory{{%/link%}} automatically.

* The {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34;%}}{{%badge%}}app-config.json{{%/badge%}}{{%/link%}} file is not created when you do a standalone deploy to deploy an app without initializing it. The information that this file carries is fetched as input from you in the CLI during the deployment.


&lt;br&gt;

You can do the standalone deploy of an AppSail app in the following way: 

1. Navigate to the directory the app&#39;s deployable files are present in, and executing the following command:

{{%cli%}}catalyst deploy appsail{{%/cli%}}

2. Enter a name for your app. You can name the main file of your app’s build anything you prefer.

&lt;br&gt;

{{%note%}}{{%bold%}}Note:{{%/bold%}} However, when you build your app as a Java WAR file, you will need to name the main file root.war or add specific controllers according to your code.{{%/note%}}

3. Select the build path for your app from the list and press **Enter**.

&lt;br&gt;

4. Select a stack for your app and press **Enter**.

&lt;br&gt;

If you select Java, the CLI will further prompt you to pick either Java SE or the Java WAR as your app&#39;s deployable format. You can learn more about this here.

&lt;br&gt;

If you select any other stack, this will be skipped.

5. You must additionally specify the startup command for your app based on the stack, framework, and web server used. This information will be directly deployed and will be available in the Configurations section of your console after the app deployment.

&lt;br&gt;

Your app is now directly deployed to the associated remote project without requiring you to initialize it as an AppSail resource. You can now access it with its endpoint URL displayed in the CLI.

&lt;br&gt;

&lt;br&gt;

### Standalone Deploy AppSail Options

The catalyst deploy appsail standalone command supports the following options. Some of these are applicable to both Catalyst-managed runtime and container images apps, while some are specific to only one of them.

{{%bold%}}--name &amp;lt;name&amp;gt;{{%/bold%}}           

Use this to specify the name of your app. This is applicable to both Catalyst-managed runtime and container image apps. Example: 

{{%cli%}}--name DemoApp{{%/cli%}}

{{%bold%}}--build-path &amp;lt;path&amp;gt;{{%/bold%}}
   
Use this to specify the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#source-directory-and-build-path&#34; %}}build path{{%/link%}} of your app. Provide an absolute path value. This is applicable only to Catalyst-managed runtime apps. Example: 

{{%cli%}}--build-path /users/amelia/catalystapp/demoapp/{{%/cli%}}

{{%bold%}}--stack &amp;lt;stack&amp;gt;{{%/bold%}}        

Use this to specify the stack or runtime of your app. You must only specify the runtimes that are supported by Catalyst. This is applicable only to Catalyst-managed runtime apps. Example:

{{%cli%}}--stack NodeJS 20{{%/cli%}}


{{%bold%}}--platform &amp;lt;javase|war&amp;gt;{{%/bold%}} 

Use this to specify the platform of the Java stack alone that are supported in Catalyst: {{%badge%}}javase{{%/badge%}} or {{%badge%}}war{{%/badge%}}. This is applicable only to Catalyst-managed runtime apps. Example:

{{%cli%}}--platform javase{{%/cli%}}

{{%bold%}}--command &amp;lt;command&amp;gt;{{%/bold%}}      

Use this to specify the {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34; %}}startup command{{%/link%}} for your app. This is applicable to both Catalyst-managed runtime and container image apps. This will override any values already configured in the container image definition. Example: 

{{%cli%}}--command npm start{{%/cli%}}


--------------------------------------------------------------------------------
title: "Deploy from the Console"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.655Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/catalyst-managed-runtimes/deploy-from-console/"
service: "Serverless"
--------------------------------------------------------------------------------


# Deploy AppSail as a Catalyst-Managed Runtime from the Console

AppSail enables you to deploy an app as a Catalyst-managed runtime from the Catalyst remote console directly in the following manner:

1. Navigate to the **Serverless** service in your Catalyst project that you wish to deploy your app in, then click **AppSail** under *Compute*.

&lt;br /&gt;

Upon clicking **Deploy from CLI**, a pop-up will show you the instructions to deploy an AppSail service from the CLI. Refer the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/deploy-from-cli/&#34; %}}CLI help section{{%/link%}} for detailed steps.

2. Click **Deploy from Console** to directly deploy your app here.

3. Select the deployment type as **Catalyst-Managed Runtime**, and provide a name for your AppSail service. Select the runtime that your app uses from a list of the runtimes supported by Catalyst. Provide a {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34; %}}startup command{{%/link%}} for your app based on your app&#39;s runtime. 

Upload a ZIP file of your AppSail&#39;s build directory.

{{%note%}}{{%bold%}}Note:{{%/bold%}} When you deploy the app on the console directly, the build directory need not include the {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/badge%}}{{%/link%}} file, as it is only required while deploying from the CLI. You can provide the configuration details here. If the {{%badge%}}app-config.json{{%/badge%}} file is present, the values you provide here will override the ones in that file.{{%/note%}}

&lt;br /&gt;

4. You can configure advanced settings for your app. 

 * Configure a {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#ports-for-app-executions&#34; %}}custom port{{%/link%}} for your app&#39;s execution, if needed. Ports within the range of 0 to 1024 are reserved, with the exception of ports 80 and 443. You can use any other ports outside this range. Port 9000 will be used by default.

{{%note%}}{{%bold%}}Note:{{%/bold%}} If you have not configured the port in your code, ensure that you configure the same port to listen to while starting the server in the {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34; %}}startup command{{%/link%}} of your app.{{%/note%}}

 * Configure the required {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#memory-and-disk-allocation&#34; %}}memory{{%/link%}} for your app&#39;s execution, based on your requirements. You can select 128, 256, 512, 1024, or 2048 MB.

{{%info%}}{{%bold%}}Info:{{%/bold%}} You can also configure the disk size for your app&#39;s execution after you deploy the app from the {{%link href=&#34;/en/serverless/help/appsail/console/overview/&#34; %}}Configuration section{{%/link%}}.{{%/info%}}

 * Configure {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#environment-variables&#34; %}}environment variables{{%/link%}} for your AppSail service as needed. 

&lt;br /&gt;

You can add multiple environment variables by clicking the **&#43;** icon, and remove them by clicking the **—** icon. 

{{%info%}}{{%bold%}}Info:{{%/bold%}} The environment variable will be added to the {{%link href=&#34;/en/deployment-and-billing/environments/introduction/&#34; %}}Catalyst environment{{%/link%}} (development or production) that you&#39;re currently working in. You can change the environment from the drop-down at the top of the console, and add variables as required.{{%/info%}}

&lt;br /&gt;

5. After you configure the details, click **Deploy**.

Your app will be deployed to the console. You will now be able to view and manage your app from the console.

&lt;br /&gt;


{{%link href=&#34;/en/serverless/help/appsail/console/manage-appsail/&#34; %}}Refer here for help on managing your AppSail service{{%/link%}}.


## Custom Runtimes


--------------------------------------------------------------------------------
title: "Container Registry Services"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.655Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/custom-runtimes/container-registry-services/"
service: "Serverless"
--------------------------------------------------------------------------------


# Container Registry Services

### Docker Hub

Catalyst facilitates an easy integration with {{%link href=&#34;https://hub.docker.com/&#34; %}}Docker Hub{{%/link%}}, one of the leading container registry services. After you configure the integration, you can easily deploy images from your Docker Hub account to AppSail from the console. You can also manage your Docker Hub connection from the console.

#### Integrate Docker Hub with Catalyst

Perform a one-time configuration to integrate your Docker Hub account with Catalyst in the following way:

1. Navigate to **Settings** in the console, then select **Integrations** under *General Settings*. Click **Docker Hub** from the list.

&lt;br /&gt;

2. Click **Add Docker Account** to add a new connection. 

&lt;br /&gt;

3. Provide a name for the connection. Then, add your Docker Hub account&#39;s username ({{%link href=&#34;https://docs.docker.com/accounts/general-faqs/&#34; %}}Docker ID{{%/link%}}) and the Personal Access Token. You can create and fetch  access tokens from Docker Home as explained in {{%link href=&#34;https://docs.docker.com/security/access-tokens/&#34; %}}this help page{{%/link%}}.

&lt;br /&gt;

4. Click **Add**.

Your connection will be created and listed on the *Docker Hub Integrations* page. You can now use this connection to {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/deploy-from-console/&#34; %}}deploy a Docker image{{%/link%}} from Docker Hub on AppSail.

&lt;br /&gt;

&lt;br&gt;

#### Edit Docker Hub Connection

You can edit an individual Docker Hub connection as described below.

1. Click the ellipsis icon of the connection that you wish to edit, then click **Edit**.

&lt;br /&gt;

2. Edit the required information. You can update the connection name, your account&#39;s username, or the personal access token. Click **Save**.

&lt;br /&gt;

&lt;br&gt;

#### Delete Docker Hub Connection

You can delete an individual Docker Hub connection as described below.

1. Click the ellipsis icon of the connection that you wish to delete, then click **Delete**.

&lt;br /&gt;

2. Click **Delete** from the confirmation pop-up.


&lt;br /&gt;

&lt;br&gt;

### Amazon Elastic Container Registry

Catalyst facilitates an easy integration with AWS that enables you to access the {{%link href=&#34;https://aws.amazon.com/ecr/&#34; %}}Amazon Elastic Container Registry{{%/link%}}. After you configure the integration, you can easily deploy images from your Amazon ECR to AppSail from the console. You can also manage your AWS connection from the console.


#### Integrate AWS with Catalyst

Perform a one-time configuration to integrate your AWS account with Catalyst in the following way:

1. Navigate to **Settings** in the console, then select **Integrations** under *General Settings*. Click **AWS** from the list.

&lt;br /&gt;

2. Click **Add AWS** to add a new connection. 

&lt;br /&gt;

3. Provide a name for the connection. Then, add your AWS account&#39;s Access Key ID and Access Key Secret. You can create and manage access key credentials in AWS as explained in {{%link href=&#34;https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html&#34; %}}this help page{{%/link%}}.

&lt;br /&gt;

4. Click **Add**.

Your connection will be created and listed on the *AWS Integrations* page. You can now use this connection to {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/deploy-from-console/&#34; %}}deploy an OCI Image{{%/link%}} from AWS ECR on AppSail.

&lt;br /&gt;

&lt;br&gt;

#### Edit AWS Connection

You can edit an individual AWS connection as described below.

1. Click the ellipsis icon of the connection that you wish to edit, then click **Edit**.

&lt;br /&gt;

2. Edit the required information. You can update the connection name, your Access Key ID and Access Key Secret. Click **Save**.

&lt;br /&gt;

&lt;br&gt;

#### Delete AWS Connection

You can delete an individual AWS connection as described below.

1. Click the ellipsis icon of the connection that you wish to delete, then click **Delete**.

&lt;br /&gt;

2. Click **Delete** from the confirmation pop-up.


&lt;br /&gt;

&lt;br&gt;

### Google Artifact Registry

Catalyst facilitates an easy integration with {{%link href=&#34;https://cloud.google.com/artifact-registry/docs/overview&#34; %}}Google Artifact Registry{{%/link%}}. After you configure the integration, you can easily deploy images from your GCP account to AppSail from the console. You can also manage your GCP connection from the console.

#### Integrate Google Cloud Platform with Catalyst

Perform a one-time configuration to integrate your GCP account with Catalyst in the following way:

1. Navigate to **Settings** in the console, then select **Integrations** under *General Settings*. Click **Google Cloud Platform** from the list.

&lt;br /&gt;

2. Click **Add GCP Account** to add a new connection. 

&lt;br /&gt;

3. Provide a name for the connection. Then, upload your GCP account&#39;s {{%link href=&#34;https://cloud.google.com/iam/docs/service-account-creds&#34; %}}Service Account Credentials JSON{{%/link%}} file which will contain your credentials information. You can get a service account key and download it as a JSON file from the Google Cloud console as explained in {{%link href=&#34;https://cloud.google.com/iam/docs/keys-list-get&#34; %}}this help page{{%/link%}}.

&lt;br /&gt;

4. Click **Add**.

Your connection will be created and listed on the *GCP Integrations* page. You can now use this connection to {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/deploy-from-console/&#34; %}}deploy an OCI Image from GCP Artifact Registry{{%/link%}} on AppSail.

&lt;br /&gt;

&lt;br&gt;

#### Edit GCP Connection

You can edit an individual GCP connection as described below.

1. Click the ellipsis icon of the connection that you wish to edit, then click **Edit**.

&lt;br /&gt;

2. Edit the required information. You can update the connection name or upload a new Service Account Credentials JSON file.  Click **Save**.

&lt;br /&gt;

&lt;br&gt;

#### Delete GCP Connection

You can delete an individual GCP connection as described below.

1. Click the ellipsis icon of the connection that you wish to delete, then click **Delete**.

&lt;br /&gt;

2. Click **Delete** from the confirmation pop-up.

&lt;br /&gt;

&lt;br&gt;


--------------------------------------------------------------------------------
title: "Deploy from CLI"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.656Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/custom-runtimes/deploy-from-cli/"
service: "Serverless"
--------------------------------------------------------------------------------


# Deploy AppSail as a Custom Runtime from the CLI

### Initialize or Add an AppSail Service

You can {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} for a custom runtime app directly in your app&#39;s directory, or from a new directory using the {{%link href=&#34;/en/cli/v1/cli-command-reference/&#34; %}}Catalyst CLI{{%/link%}}. You can also {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add an AppSail service{{%/link%}} to an existing Catalyst project directory, where other resources have been initialized. You can [deploy the AppSail service](#deploy-an-appsail-service) after you initialize or add it.

To initialize an AppSail service in a new directory, create a folder for your project in your local machine and navigate to it from your terminal. Initialize a project by executing the following command from that directory:

{{%cli%}}catalyst init{{%/cli%}}

You can add an AppSail service in an existing Catalyst project directory by executing this CLI command:

{{%cli%}}catalyst appsail:add{{%/cli%}}

&lt;br&gt;

Catalyst supports two protocols for custom runtime apps that you can use to associate your app&#39;s image with AppSail. Each protocol has a distinct schema for identification and functioning. 

* {{%bold%}}Docker Image Protocol:{{%/bold%}} Use this to associate a pre-built image of your app present in the local docker registry. The image must be built and {{%link href=&#34;https://docs.docker.com/reference/cli/docker/image/tag/&#34; %}}tagged{{%/link%}} to point to the local registry. Example: *docker://localhost/expres-hw:latest*

* {{%bold%}}Docker Archive Protocol:{{%/bold%}} Use this to point to an archive file (.tar or .tar.gz) of a pre-built image of your app in your system&#39;s directory. Example: *docker-archive://test.tar*

{{%note%}}{{%bold%}}Note:{{%/bold%}} The {{%badge%}}.tar{{%/badge%}} file can be typically generated with the {{%link href=&#34;https://docs.docker.com/reference/cli/docker/image/save/&#34; %}}{{%badge%}}docker save{{%/badge%}} command{{%/link%}}.{{%/note%}}

You need not provide any other details except the name for the AppSail for container images. The source or build path of the app, stack, and startup command are not required to be configured for OCI images, as they are already defined in the images. The steps to initialize or add the AppSail service will be the same as described below:

1. The CLI will prompt you to select the runtime type as Catalyst-Managed Runtime or **Docker Image** when AppSail is initialized. Select the second option.


2. Select the protocol as **Docker Image** or **Docker Archive**.


3. {{%bold%}}Docker Image Protocol:{{%/bold%}}

If you select **Docker Image**, the CLI will list all the available images with tags in the local docker registry. Select the image you need.


{{%bold%}}Docker Archive Protocol:{{%/bold%}}

If you select **Docker Archive**, the CLI will prompt you to enter the absolute path to the TAR file image of your app in your local system.


{{%note%}}{{%bold%}}Note:{{%/bold%}} When the AppSail configuration is stored in the {{%link href=&#34;/en/cli/v1/project-directory-structure/catalyst-json/&#34; %}}{{%badge%}}catalyst.json{{%/badge%}}{{%/link%}} file, the path will be stored relative to that file&#39;s location.{{%/note%}}

4. Provide a name for the AppSail service. You can name it anything you prefer.


AppSail is now initialized in your local directory, and the app&#39;s image is now associated with the AppSail service. The configurations will be updated in {{%link href=&#34;/en/cli/v1/project-directory-structure/catalyst-json/&#34; %}}{{%badge%}}catalyst.json{{%/badge%}}{{%/link%}} file accordingly.


{{%note%}}{{%bold%}}Note:{{%/bold%}} The {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}{{%badge%}}app-config.json{{%/link%}}{{%/badge%}} file will not be created when you initialize AppSail with a container image. All the app specifications will be stored in the {{%badge%}}catalyst.json{{%/badge%}} file. You can add certain custom configurations of your app in this file. Refer {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/&#34; %}}here{{%/link%}} for details.{{%/note%}}


You can now code your business logic in your app, then {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}serve the AppSail service{{%/link%}} through a localhost to {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}debug{{%/link%}} and test it, or {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/#the-app-configjson-file&#34; %}}deploy it{{%/link%}} to the remote console directly.

### Deploy an AppSail Service

Catalyst enables you to deploy {{%link href=&#34;/en/serverless/help/appsail/introduction/&#34; %}}AppSail services{{%/link%}} in two different ways:

* {{%bold%}}Regular Deploy:{{%/bold%}} The regular deploy execution applies when you have already initialized an AppSail resource either during the {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}project initialization{{%/link%}} or by {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}adding it in an existing project directory{{%/link%}}. 

* {{%bold%}}Standalone Deploy:{{%/bold%}} You can do a standalone deploy of an app directly without initializing it as an AppSail service in prior. 

The OCI image of your app that is associated with Appsail is deployed, along with the configuration file of your project.

{{%note%}}{{%bold%}}Note:{{%/bold%}} Catalyst only supports the deployment of {{%link href=&#34;https://github.com/opencontainers/image-spec&#34; %}}OCI-compliant images{{%/link%}} built for the Linux AMD64 (x86-64) platform.{{%/note%}}

&lt;br&gt;

### Regular Deploy

If the AppSail app is already initialized in the project directory, the CLI will automatically deploy the app with the rest of the project resources when you execute the {{%badge%}}catalyst deploy{{%/badge%}} command. The CLI will display the endpoint URL of the app after it is deployed, that you can open it with.

&lt;br&gt;

If you have multiple AppSail apps in your project directory, you can access all of their URL endpoints from the CLI.

You can also execute the following command to deploy the AppSail service alone from your app&#39;s source directory.

{{%cli%}}catalyst deploy appsail{{%/cli%}}

The deployment process is the same.

&lt;br&gt;
 
&lt;br&gt;

### Standalone Deploy

You must execute the standalone deploy command from a Catalyst project directory&#39;s root. That is, {{%badge%}}catalyst.json{{%/badge%}} and other {{%link href=&#34;/en/cli/v1/project-directory-structure/introduction/&#34; %}}project dependency files{{%/link%}} must be present in the directory.

{{%note%}}{{%bold%}}Note:{{%/bold%}} If you execute the standalone deploy command without any of the [options specific to deploying container images](#standalone-deploy-appsail-options), the CLI will prompt you for inputs related to Catalyst-managed runtime apps only by default. {{%/note%}}

You can use the standalone deploy command with these options to deploy apps as container images: {{%badge%}}--name &amp;lt;name&amp;gt;{{%/badge%}}, {{%badge%}}--source &amp;lt;image&amp;gt;{{%/badge%}}, {{%badge%}}--command &amp;lt;command&amp;gt;{{%/badge%}}, {{%badge%}}--port &amp;lt;port&amp;gt;{{%/badge%}}. The first two are mandatory, while the last two are optional and can be used to override any startup commands or ports already configured in the container image definition. The options are explained in detail below.

&lt;br&gt;

You can do the standalone deploy of an AppSail app in the following way: 

1. Navigate to the directory the app&#39;s deployable files are present in, and executing the following command:

{{%cli%}}catalyst deploy appsail{{%/cli%}}

2. Enter a name for your app. You can name the main file of your app’s build anything you prefer.

&lt;br&gt;

{{%note%}}{{%bold%}}Note:{{%/bold%}} However, when you build your app as a Java WAR file, you will need to name the main file root.war or add specific controllers according to your code.{{%/note%}}

3. Select the build path for your app from the list and press **Enter**.

&lt;br&gt;

4. Select a stack for your app and press **Enter**.

&lt;br&gt;

If you select Java, the CLI will further prompt you to pick either {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34;%}}Java SE or the Java WAR{{%/link%}} as your app&#39;s deployable format. 

&lt;br&gt;

If you select any other stack, this will be skipped.

5. You must additionally specify the startup command for your app based on the stack, framework, and web server used. This information will be directly deployed and will be available in the Configurations section of your console after the app deployment.

&lt;br&gt;

Your app is now directly deployed to the associated remote project without requiring you to initialize it as an AppSail resource. You can now access it with its endpoint URL displayed in the CLI.

&lt;br&gt;

&lt;br&gt;

### Standalone Deploy AppSail Options

The catalyst deploy appsail standalone command supports the following options. Some of these are applicable to both Catalyst-managed runtime and container images apps, while some are specific to only one of them.

{{%bold%}}--name &amp;lt;name&amp;gt;{{%/bold%}}           

Use this to specify the name of your app. This is applicable to both Catalyst-managed runtime and container image apps. Example: 

{{%cli%}}--name DemoApp{{%/cli%}}

{{%bold%}}--command &amp;lt;command&amp;gt;{{%/bold%}}      

Use this to specify the {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34; %}}startup command{{%/link%}} for your app. This is applicable to both Catalyst-managed runtime and container image apps. This will override any values already configured in the container image definition. Example: 

{{%cli%}}--command npm start{{%/cli%}}

{{%bold%}}--source &amp;lt;image&amp;gt;{{%/bold%}}      

Use this to specify the source of the docker image to be deployed. This is applicable only to container image apps. You must start with &#39;*docker://*&#39; for Docker image protocol and &#39;*docker-archive://*&#39; for Docker archive protocol. {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/#initialize-appsail-as-a-custom-runtime&#34; %}}Refer here for details{{%/link%}}. Example:

{{%cli%}}--source docker://example-voting-app-worker:latest{{%/cli%}}


{{%bold%}}--port &amp;lt;port&amp;gt;{{%/bold%}}           

Use this to specify the port for the AppSail. This is applicable only to container image apps. This will override any values already configured in the container image definition. Example:

{{%cli%}}--port 8000{{%/cli%}}


--------------------------------------------------------------------------------
title: "Deploy from the Console"
description: "Catalyst AppSail is a fully-managed platform of Catalyst Serverless that enables you to develop and deploy web services in managed runtimes of Java, Node.js, and Python, or of custom runtimes as OCI images to the cloud with ease."
last_updated: "2026-03-18T07:41:08.656Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/custom-runtimes/deploy-from-console/"
service: "Serverless"
--------------------------------------------------------------------------------


# Deploy AppSail as a Custom Runtime from the Console

AppSail enables you to deploy an app as a container image from the Catalyst console directly. The steps given here are common for all the Container Registry services. 

1. Navigate to the **Serverless** service in your Catalyst project that you wish to deploy your app in, then click **AppSail** under *Compute*.

&lt;br /&gt;

Upon clicking **Deploy from CLI**, a pop-up will show you the instructions to deploy an AppSail service from the CLI. Refer the {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/deploy-from-cli/&#34; %}}CLI help section{{%/link%}} for detailed steps.

2. Click **Deploy from Console** to directly deploy your app here.

3. Select the deployment type as **Docker Image**, and provide a name for your AppSail service. Select the deployment type as Docker Image, and select the Container Registry Service from the list: {{%link href=&#34;https://hub.docker.com/&#34; %}}Docker Hub{{%/link%}}, {{%link href=&#34;https://aws.amazon.com/ecr/&#34; %}}AWS ECR{{%/link%}}, or {{%link href=&#34;https://cloud.google.com/artifact-registry/docs/overview&#34; %}}Google Artifact Registry{{%/link%}}. 

Enter the following according to the service you choose- 

* Docker Hub- {{%link href=&#34;https://docs.docker.com/get-started/docker-concepts/building-images/build-tag-and-publish-an-image/&#34; %}}Image URL{{%/link%}}
* Amazon ECR- {{%link href=&#34;https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-info.html&#34; %}}Image URI{{%/link%}}
* GCP Artifact Registry- {{%link href=&#34;https://cloud.google.com/artifact-registry/docs/container-concepts&#34; %}}Image Path{{%/link%}} 

Refer to the help links on details to fetch them.

&lt;br /&gt;


4. You must select the credentials of the Container Registry Service that you will use for your OCI image deployment. The drop-down will list all the credentials that you have configured with the container service. 

    You can select an existing credential or click the **Create Integration** button below to add a new credential. This will redirect you to {{%link href=&#34;/en/getting-started/set-up-a-catalyst-project/integrations-settings/&#34; %}}Integration Settings{{%/link%}} . 

&lt;br /&gt;

{{%note%}}{{%bold%}}Note:{{%/bold%}} The steps to add and manage Catalyst integrations for  {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/container-registry-services/#docker-hub&#34; %}}Docker Hub{{%/link%}}, {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/container-registry-services/#amazon-elastic-container-registry&#34; %}}AWS{{%/link%}}, or {{%link href=&#34;/en/serverless/help/appsail/custom-runtimes/container-registry-services/#google-artifact-registry&#34; %}}Google Cloud Platform{{%/link%}} are covered in their respective help sections. {{%/note%}}

&lt;br /&gt;

5. You can configure advanced settings for your app. 

 i. Provide a {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#startup-commands&#34; %}}startup command{{%/link%}} for your app based on your app&#39;s runtime. 

{{%note%}}{{%bold%}}Note:{{%/bold%}} If you have already d the startup command in your container image, the command you provide in Catalyst will take priority.{{%/note%}}

 ii. Configure a {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#ports-for-app-executions&#34; %}}custom port{{%/link%}} for your app&#39;s execution, if needed. Ports within the range of 0 to 1024 are reserved, with the exception of ports 80 and 443. You can use any other ports outside this range. Port 9000 will be used by default.

{{%note%}}{{%bold%}}Note:{{%/bold%}} If you have not configured the port in your code, ensure that you configure the same port to listen to while starting the server in the startup command of your app.{{%/note%}}

 iii. Configure the required {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#memory-and-disk-allocation&#34; %}}memory{{%/link%}} for your app&#39;s execution, based on your requirements. You can select 128, 256, 512, 1024, or 2048 MB.

{{%info%}}{{%bold%}}Info:{{%/bold%}} You can also configure the disk size for your app&#39;s execution after you deploy the app from the {{%link href=&#34;/en/serverless/help/appsail/console/overview/&#34; %}}Configuration section{{%/link%}}.{{%/info%}}

 iv. Configure {{%link href=&#34;/en/serverless/help/appsail/appsail-configurations/#environment-variables&#34; %}}environment variables{{%/link%}} for your AppSail service as needed. 

&lt;br /&gt;

You can add multiple environment variables by clicking the **&#43;** icon, and remove them by clicking the **—** icon. 

{{%info%}}{{%bold%}}Info:{{%/bold%}} The environment variable will be added to the {{%link href=&#34;/en/deployment-and-billing/environments/introduction/&#34; %}}Catalyst environment{{%/link%}} (development or production) that you&#39;re currently working in. You can change the environment from the drop-down at the top of the console, and add variables as required.{{%/info%}}

6. After you configure the details, click **Deploy**.

Your app will be deployed to the console. You will now be able to view and manage your app from the console.

&lt;br /&gt;


{{%link href=&#34;/en/serverless/help/appsail/console/manage-appsail/&#34; %}}Refer here for help on managing your AppSail service{{%/link%}}.


## Quick Start for Catalyst-Managed Runtimes


--------------------------------------------------------------------------------
title: "Introduction"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.657Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/introduction/"
service: "Serverless"
--------------------------------------------------------------------------------


# Quick Start for Catalyst-Managed Runtimes of Java, Node.js, and Python

### Introduction

This section covers examples of building sample applications with popular frameworks of each programming environment of a {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtime{{%/link%}}. 

Catalyst defines no restrictions on the frameworks that you might use for the supported programming environments, Java, Node.js, and Python to build your apps. Based on the language and framework you use, you can incorporate plugins, libraries, extensions, or any other dependencies that you might require.


{{%note%}}{{%bold%}}Note:{{%/bold%}} When you build your Catalyst-managed runtime app in your local environment, you might incorporate operating system-specific dependencies in it. However, after you deploy your app as an AppSail service, the dependencies might not work as Catalyst might use different OS and architecture specifications to run your app. Therefore, it is best to avoid using any OS-specific dependencies in your app bundle.{{%/note%}}

### Java


--------------------------------------------------------------------------------
title: "Overview"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.657Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/java/overview/"
service: "Serverless"
--------------------------------------------------------------------------------


# Java

### Overview

The Java programming environment includes a variety of frameworks that contain pre-written classes, templates, packages, and structure upon which you can build your own code. As mentioned earlier, Catalyst enables you to {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize{{%/link%}} or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add{{%/link%}} an AppSail service in one of these two formats:

* {{%link href=&#34;https://docs.oracle.com/cd/E19199-01/816-6774-10/a_war.html&#34; %}}Java- WAR{{%/link%}}
* {{%link href=&#34;https://www.oracle.com/cis/java/technologies/java-se-glance.html&#34; %}}Java- SE{{%/link%}}
 
After you select the Java stack while initializing an app service, you can select one of these options.  However, you can still build your Java application with any frameworks; incorporate any libraries, modules, or dependencies; generate it as any standard package; and follow any editions you require.

{{%note%}}{{%bold%}}Note:{{%/bold%}} When you use the Java WAR template for deploying your Java application exported as a WAR file, you need not embed a Java web server in your application, as AppSail will bundle your application with a server by default. If you choose Java SE as your template for all other Java application formats, such as a JAR file, you will need to include an embedded server in your application.{{%/note%}}

The Java help guide contains step-by-step instructions on building basic sample apps with some of the most popular frameworks, using popular Java web servers in them, and deploying these apps as AppSail services, and configuring {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup commands{{%/link%}} as required.

&lt;br&gt;

### Prerequisites

Depending on the framework, server, and edition you use in these examples, you will need to ensure that you have all the prerequisites installed in your local machine.


--------------------------------------------------------------------------------
title: "Embedded Jetty"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.657Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/java/embedded-jetty/"
service: "Serverless"
--------------------------------------------------------------------------------


# Simple Java App with Embedded Jetty

This example illustrates the steps to build a simple Java app with a {{%link href=&#34;https://docs.oracle.com/cd/E19199-01/816-6774-10/a_war.html&#34; %}}Jetty server{{%/link%}} embedded in it. Eclipse Jetty is a lightweight Java web server as well as a servlet container. This application will then be compiled, bundled, and associated with an AppSail service as a Java SE type, and deployed to the console.

1. Create a new Java project from an IDE of your choice.

2. Include the following libraries in your source directory. We have created a new folder in this example and named it deps. These JAR files include all the servlets, utility files, and other dependencies that will embed the Jetty server into your application. You can fetch these dependencies from the {{%link href=&#34;https://mvnrepository.com/&#34; %}}official Maven repository{{%/link%}}. You can also add these as Maven dependencies.

{{%code class=&#34;language-json&#34;%}}javax.servlet-api-3.1.0.jar
jetty-io-9.4.50.v20221201.jar
jetty-server-9.4.50.v20221201.jar
jetty-util-9.4.50.v20221201.jar
jetty-http-9.4.50.v20221201.jar
jetty-security-9.4.50.v20221201.jar
jetty-servlet-9.4.50.v20221201.jar
jetty-util-ajax-9.4.50.v20221201.jar{{%/code%}}

&lt;br&gt;

3. To create an embedded Jetty application, you will need to create an instance of org.eclipse.jetty.server.Server class and refer to the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#default-port-for-app-startups&#34;%}}listening port{{%/link%}} with the environment variable {{%badge%}}X_ZOHO_CATALYST_LISTEN_PORT{{%/badge%}} in your main code. You must add a Servlet handler to handle these requests. Create the following Java files in your main directory and add the sample code snippets given below:

**CustomJettyServer.java**

{{%code class=&#34;language-java&#34;%}}import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
public class CustomJettyServer 
{
    public static void main( String[] args ) throws Exception
    {
 String port = System.getenv(&#34;X_ZOHO_CATALYST_LISTEN_PORT&#34;);
 int listenPort;
        if(port != null &amp;&amp; !port.isEmpty()) {
            listenPort = Integer.parseInt(System.getenv(&#34;X_ZOHO_CATALYST_LISTEN_PORT&#34;));
        } else {
            listenPort = 9000;
        }
 Server server = new Server(listenPort);
        ServletContextHandler handler = new ServletContextHandler();
        handler.addServlet(ServletHandler.class.getName(), &#34;/&#34;);
        server.setHandler(handler);
        server.start();
    }
}{{%/code%}}

&lt;br&gt;

**ServletHandler.java**

{{%code class=&#34;language-java&#34;%}}import java.io.IOException;
import java.nio.charset.StandardCharsets;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ServletHandler extends HttpServlet{
 @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String path = req.getServletPath();
        System.out.println(path);

        try {
            resp.getWriter().write(&#34;Hello ABC&#34;);
            resp.getWriter().close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doPut(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doHead(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
    @Override
    protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        this.doPost(req, resp);
    }
}{{%/code%}}

&lt;br&gt;

4. Compile the application by executing the command given below:

{{%code class=&#34;language-json&#34;%}}javac -cp &#34;.:./*:./deps/*&#34; *.java{{%/code%}}

&lt;br&gt;

5. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following values while initializing the app service:

    **Stack:** Java 8 &lt;br&gt;
    **Platform:** Java SE


6. Ensure the compiled file, along with the JAR files in the deps folder, are added in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 


7. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.  

8. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-java&#34;%}}java -cp &#34;.:./*:./deps/*&#34; *.java{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Spring MVC"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.657Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/java/spring-mvc/"
service: "Serverless"
--------------------------------------------------------------------------------


# Spring- MVC

The {{%link href=&#34;https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/mvc.html&#34; %}}Spring Web MVC{{%/link%}} framework is a module of the popular {{%link href=https://spring.io&#34; %}}Spring framework{{%/link%}} that follows a Model-View-Controller architecture. This framework allows for the creation of web applications, incorporating the advantages of the Spring framework along with loose coupling of components in the MVC design pattern. It is built around a {{%badge%}}DispatcherServlet{{%/badge%}} that handles HTTP requests and responses, and dispatches the requests to necessary handlers and controllers.

This example explains the steps to build a sample app in the Spring MVC framework, export it as a WAR file, and deploy it to AppSail. 

1. Create a new Maven project using an IDE of your choice. You must select the following {{%link href=&#34;https://maven.apache.org/guides/introduction/introduction-to-archetypes.html&#34; %}}Archetype{{%/link%}} for the project: {{%badge%}}org.apache.maven.archetypes maven-archetype-webapp{{%/badge%}}.

2. In the {{%badge%}}pom.xml{{%/badge%}} file of your project, add the spring dependencies given below.

{{%code class=&#34;language-java&#34;%}}&amp;lt;dependency&amp;gt;
 	&amp;lt;groupId&amp;gt;org.springframework&amp;lt;/groupId&amp;gt;
  &amp;lt;artifactId&amp;gt;spring-core&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;5.2.19.RELEASE&amp;lt;/version&amp;gt;
 &amp;lt;/dependency&amp;gt;
 &amp;lt;dependency&amp;gt;
  &amp;lt;groupId&amp;gt;org.springframework&amp;lt;/groupId&amp;gt;
  &amp;lt;artifactId&amp;gt;spring-context&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;5.2.19.RELEASE&amp;lt;/version&amp;gt;
 &amp;lt;/dependency&amp;gt;
 &amp;lt;dependency&amp;gt;
  &amp;lt;groupId&amp;gt;org.springframework&amp;lt;/groupId&amp;gt;
  &amp;lt;artifactId&amp;gt;spring-aop&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;5.2.19.RELEASE&amp;lt;/version&amp;gt;
 &amp;lt;/dependency&amp;gt;
 &amp;lt;dependency&amp;gt;
  &amp;lt;groupId&amp;gt;org.springframework&amp;lt;/groupId&amp;gt;
  &amp;lt;artifactId&amp;gt;spring-webmvc&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;5.2.19.RELEASE&amp;lt;/version&amp;gt;
 &amp;lt;/dependency&amp;gt;
 &amp;lt;dependency&amp;gt;
  &amp;lt;groupId&amp;gt;org.springframework&amp;lt;/groupId&amp;gt;
  &amp;lt;artifactId&amp;gt;spring-web&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;5.2.19.RELEASE&amp;lt;/version&amp;gt;
 &amp;lt;/dependency&amp;gt;
 &amp;lt;dependency&amp;gt;
  &amp;lt;groupId&amp;gt;javax.servlet&amp;lt;/groupId&amp;gt;
  &amp;lt;artifactId&amp;gt;jstl&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;1.2&amp;lt;/version&amp;gt;
 &amp;lt;/dependency&amp;gt;{{%/code%}}

&lt;br&gt;

3. Add the dependencies below in a build enclosure to compile and generate the WAR file.

{{%code class=&#34;language-java&#34;%}}&amp;lt;plugins&amp;gt;
	&amp;lt;plugin&amp;gt;
 	&amp;lt;artifactId&amp;gt;maven-compiler-plugin&amp;lt;/artifactId&amp;gt;
  &amp;lt;version&amp;gt;3.8.0&amp;lt;/version&amp;gt;
  &amp;lt;configuration&amp;gt;
  	&amp;lt;source&amp;gt;1.8&amp;lt;/source&amp;gt;
   &amp;lt;target&amp;gt;1.8&amp;lt;/target&amp;gt;
  &amp;lt;/configuration&amp;gt;
 &amp;lt;/plugin&amp;gt;
 &amp;lt;plugin&amp;gt;
 	&amp;lt;artifactId&amp;gt;maven-war-plugin&amp;lt;/artifactId&amp;gt;
 	&amp;lt;version&amp;gt;3.2.1&amp;lt;/version&amp;gt;
  &amp;lt;configuration&amp;gt;
  	&amp;lt;warSourceDirectory&amp;gt;WebContent&amp;lt;/warSourceDirectory&amp;gt;
  &amp;lt;/configuration&amp;gt;
 &amp;lt;/plugin&amp;gt;
&amp;lt;/plugins&amp;gt;{{%/code%}}

&lt;br&gt;

4. Create a {{%link href=&#34;https://docs.spring.io/spring-framework/docs/4.2.x/spring-framework-reference/html/xsd-configuration.html&#34; %}}Spring XML configuration file{{%/link%}} in your project, and add the bean configurations given below. 

{{%code class=&#34;language-java&#34;%}}&amp;lt;beans xmlns=&#34;http://www.springframework.org/schema/beans&#34;
xmlns:context=&#34;http://www.springframework.org/schema/context&#34;
xmlns:xsi=&#34;http://www.w3.org/2001/XMLSchema-instance&#34;
xmlns:mvc=&#34;http://www.springframework.org/schema/mvc&#34;
xsi:schemaLocation=&#34;http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
&#34;&amp;gt;{{%/code%}}

Your Spring configuration file should look something like this:

{{%code class=&#34;language-java&#34;%}}&amp;lt;?xml version=&#34;1.0&#34; encoding=&#34;UTF-8&#34;?&amp;gt;
&amp;lt;beans xmlns=&#34;http://www.springframework.org/schema/beans&#34;
xmlns:context=&#34;http://www.springframework.org/schema/context&#34;
xmlns:xsi=&#34;http://www.w3.org/2001/XMLSchema-instance&#34;
xmlns:mvc=&#34;http://www.springframework.org/schema/mvc&#34;
xsi:schemaLocation=&#34;http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
&#34;&amp;gt;
&amp;lt;mvc:annotation-driven/&amp;gt;
&amp;lt;mvc:default-servlet-handler/&amp;gt;
&amp;lt;context:component-scan base-package=&#34;com.amelia.example.controller&#34; /&amp;gt;	
&amp;lt;bean class=&#34;org.springframework.web.servlet.view.InternalResourceViewResolver&#34;&amp;gt;
&amp;lt;property name=&#34;prefix&#34; value=&#34;/&#34;&amp;gt;&amp;lt;/property&amp;gt;
&amp;lt;property name=&#34;suffix&#34; value=&#34;.jsp&#34;&amp;gt;&amp;lt;/property&amp;gt;
&amp;lt;/bean&amp;gt;
&amp;lt;/beans&amp;gt;
{{%/code%}}

&lt;br&gt;

5. Add a server runtime to the project. For example, if you are working in the Eclipse IDE, you can add a targeted runtime for the Apache Tomcat server in the following way: Right click on the **project -&amp;gt; Properties -&amp;gt; Targeted Runtime**. Here, you can add the required runtime, then click **Apply**.

6. You can now add the required controller and error page handling, as well as a servlet mapping in the {{%badge%}}web.xml{{%/badge%}} file of your project. For example, you can use the configuration given below:

{{%code class=&#34;language-java&#34;%}}&amp;lt;welcome-file-list&amp;gt;
 &amp;lt;welcome-file&amp;gt;index.jsp&amp;lt;/welcome-file&amp;gt;
 &amp;lt;/welcome-file-list&amp;gt;
 &amp;lt;servlet&amp;gt;
 &amp;lt;servlet-name&amp;gt;helloworld&amp;lt;/servlet-name&amp;gt;
 &amp;lt;servlet-class&amp;gt;org.springframework.web.servlet.DispatcherServlet&amp;lt;/servlet-class&amp;gt;
 &amp;lt;load-on-startup&amp;gt;1&amp;lt;/load-on-startup&amp;gt;
 &amp;lt;/servlet&amp;gt;
 &amp;lt;servlet-mapping&amp;gt;
 &amp;lt;servlet-name&amp;gt;helloworld&amp;lt;/servlet-name&amp;gt;
 &amp;lt;url-pattern&amp;gt;/&amp;lt;/url-pattern&amp;gt;
 &amp;lt;/servlet-mapping&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;404&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;401&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;500&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;400&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;403&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;408&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;413&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;414&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;505&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;405&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;error-code&amp;gt;409&amp;lt;/error-code&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;
 &amp;lt;error-page&amp;gt;
  &amp;lt;exception-type&amp;gt;
   java.lang.Throwable
  &amp;lt;/exception-type&amp;gt;
  &amp;lt;location&amp;gt;/error.jsp&amp;lt;/location&amp;gt;
 &amp;lt;/error-page&amp;gt;{{%/code%}}

&lt;br&gt;

7. You can upload the application to Catalyst by exporting it as a WAR file. In the Eclipse example, you can right click on the project and choose **Export As -&amp;gt; WAR**. You must do the following:

    a. Choose a destination with file name as {{%badge%}}ROOT.war{{%/badge%}} &lt;br&gt;
    b. Uncheck the Optimize for specific server runtime option. 

&lt;br&gt;

8. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following values while initializing the app service:

    **Stack:** Java 8 &lt;br&gt;
    **Platform:** Java WAR


9. Ensure the compiled files are added in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

10. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Spring Boot"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.657Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/java/spring-boot/"
service: "Serverless"
--------------------------------------------------------------------------------


# Spring Boot

{{%link href=&#34;https://spring.io/projects/spring-boot&#34; %}}Spring Boot{{%/link%}} is built on top of the popular {{%link href=&#34;https://spring.io&#34; %}}Spring framework{{%/link%}}, and includes a wide range of enhancements that allow you to easily build production-grade microservices, web applications, and standalone Spring projects with reduced development efforts. Spring Boot typically includes embedded HTTP servers like Jetty or Apache Tomcat, without the complex XML configurations of Spring. 

{{%note%}}{{%bold%}}Note:{{%/bold%}} When you export a Spring Boot app as a JAR file in the example below, you can retain the embedded server included in it. However, when you export the Spring Boot app as a WAR file, you will need to exclude the embedded server included in it, if you initialize it as Java WAR in AppSail. This is because AppSail offers native support for WAR files and bundles them with the Jetty server by default.{{%/note%}}


### Spring Boot- JAR

This example illustrates the steps to build a sample Spring Boot app, export it as a JAR file, and deploy it to AppSail. 

1. Open {{%link href=&#34;https://start.spring.io/&#34; %}}Spring Initializr{{%/link%}} to create a new project. 

2. Choose the following configurations for your project:&lt;br&gt;&lt;br&gt;
    a. Project - Maven Project&lt;br&gt;
    b. Language - Java&lt;br&gt;
    c. Spring Boot Version - 2.7.10&lt;br&gt;
    d. Package - JAR&lt;br&gt;
    e. Java Version - 8&lt;br&gt;
    f. Click **Add Dependencies** and select **Spring Web**.

3. Click **Generate**.

4. Unzip the project and open it in any IDE of your choice.

5. Add necessary controllers to the project. For example, create a file named {{%badge%}}DemoController.java{{%/badge%}} in the main Java file&#39;s directory of your project, and add the controller specified below in the file.

{{%code class=&#34;language-java&#34;%}}package com.example.demo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DemoController {
    @GetMapping(&#34;/&#34;)
    public String index() {
        return &#34;Greetings from Spring Boot!&#34;;
    }
}{{%/code%}}

&lt;br&gt;

6. Catalyst will check the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#default-port-for-app-startups&#34;%}}port configured for listening{{%/link%}} with the environment variable {{%badge%}}X_ZOHO_CATALYST_LISTEN_PORT{{%/badge%}} and the app must listen to that port on all interfaces (host 0.0.0.0). Therefore, you will need to customize the port. You can do this by creating a file named {{%badge%}}ServerPortCustomizer.java{{%/badge%}} in the main Java file&#39;s directory of your project, and adding the code specified below in it:

{{%code class=&#34;language-java&#34;%}}package com.example.demo;
import org.springframework.boot.web.server.ConfigurableWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.stereotype.Component;
@Component
public class ServerPortCustomizer implements WebServerFactoryCustomizer&lt;ConfigurableWebServerFactory&gt; {
    @Override
    public void customize(ConfigurableWebServerFactory factory) {
        String port = System.getenv(&#34;X_ZOHO_CATALYST_LISTEN_PORT&#34;);
        int listenPort;
        if(port != null &amp;&amp; !port.isEmpty()) {
            listenPort = Integer.parseInt(System.getenv(&#34;X_ZOHO_CATALYST_LISTEN_PORT&#34;));
        } else {
            listenPort = 9000;
        }
        factory.setPort(listenPort);
    }
}{{%/code%}}

You can now save the application and run it in Catalyst. 

7. You can run this application on your local machine by executing the following command from your terminal:

{{%code class=&#34;language-java&#34;%}}./mvnw spring-boot:run{{%/code%}}

8. You can then compile the source code, run tests, and package the compiled code by executing the following command:


{{%code class=&#34;language-java&#34;%}}./mvnw clean package{{%/code%}}

This will generate the JAR file of the application in the target folder.

9. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following values while initializing the app service:

    **Stack:** Java 8 &lt;br&gt;
    **Platform:** Java SE

10. Ensure the JAR file is added in the build directory you specified during initialization. Catalyst will automatically ZIP your app file during deployment to the remote console. 

11. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

12. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-java&#34;%}}java -jar demo-0.0.1-SNAPSHOT.jar{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.

&lt;br&gt;
&lt;br&gt;

### Spring Boot - WAR

This example explains the steps to build a sample Spring Boot app, export it as a WAR file, and deploy it to AppSail:

1. Open {{%link href=&#34;https://start.spring.io/&#34; %}}Spring Initializr{{%/link%}} to create a new project. 

2. Choose the following configurations for your project:&lt;br&gt;&lt;br&gt;
    a. Project - Maven Project&lt;br&gt;
    b. Language - Java&lt;br&gt;
    c. Spring Boot Version - 2.7.10&lt;br&gt;
    d. Package - WAR&lt;br&gt;
    e. Java Version - 8&lt;br&gt;
    f. Click **Add Dependencies** and select **Spring Web**.

3. Click **Generate**.

4. Unzip the project and open in any IDE of your choice.

5. You must now add necessary controllers to the project. For example, create a file named {{%badge%}}DemoController.java{{%/badge%}} in the main Java file&#39;s directory of your project, and add the controller specified below in the file.

{{%code class=&#34;language-java&#34;%}}package com.example.demo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class DemoController {
    @GetMapping(&#34;/&#34;)
    public String index() {
        return &#34;Greetings from Spring Boot WAR!&#34;;
    }
}{{%/code%}}

&lt;br&gt;

6. You must now modify the {{%badge%}}pom.xml{{%/badge%}} file in your project to exclude the embedded Tomcat server while generating the WAR file, as explained in the overview. You can do this by adding the snippet given below in the {{%badge%}}spring-boot-maven-plugin enclosure{{%/badge%}} in the XML file:

{{%code class=&#34;language-json&#34;%}}&amp;lt;configuration&amp;gt;
&amp;lt;mainClass&amp;gt;${main_class_name}&amp;lt;/mainClass&amp;gt;
&amp;lt;classifier&amp;gt;exec&amp;lt;/classifier&amp;gt;
&amp;lt;/configuration&amp;gt;{{%/code%}}

&lt;br&gt;

7. You can run this application on your local machine by executing the following command from your terminal:

{{%code class=&#34;language-java&#34;%}}./mvnw spring-boot:run{{%/code%}}

&lt;br&gt;

8. You can upload the application to Catalyst with this command:

{{%code class=&#34;language-java&#34;%}}./mvnw clean package{{%/code%}}

This will generate the WAR file of the application in the target folder.

9. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following values while initializing the app service:

    **Stack:** Java 8 &lt;br&gt;
    **Platform:** Java WAR

10. Ensure the WAR file is added in the build directory you specify during initialization. Catalyst will automatically ZIP your app file during deployment to the remote console. 

11. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.    

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


### Node.js


--------------------------------------------------------------------------------
title: "Overview"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/overview/"
service: "Serverless"
--------------------------------------------------------------------------------


# Node.js

### Overview

The Node.js programming environment boasts of a variety of frameworks for both server-side and web client development, and even a host of full-stack frameworks.  These frameworks are equipped with pre-written libraries, templates, plugins, and features upon which you can build your own code. Some frameworks are MVC-oriented, some contribute to building end-to-end dynamic web apps or REST APIs, while some are mounted on top of other frameworks. Based on your application needs, you can opt for the right framework.

AppSail does not provide any templates for specific Node.js frameworks, and therefore does not contain any framework restrictions. You can build your app service using any Node.js technology that you prefer, and incorporate any libraries, modules, or dependencies. You can then directly select a Node.js runtime while initializing the app service in the CLI, and deploy it to AppSail.

The Node.js help guide contains step-by-step instructions on building basic sample apps with some of its most popular frameworks, deploying these apps as AppSail services, and configuring {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup commands{{%/link%}} as required.


### Prerequisites

{{%link href=&#34;https://nodejs.org/en/download&#34; %}}Download{{%/link%}} and install Node.js on your local machine.


--------------------------------------------------------------------------------
title: "Express"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/express/"
service: "Serverless"
--------------------------------------------------------------------------------


# Express Framework

{{%link href=&#34;https://expressjs.com/&#34; %}}Express{{%/link%}} is a highly robust and minimalist framework that comes bundled with a host of HTTP utility methods and middleware. 

This example illustrates the steps to build a simple Node.js app with the Express framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Express app.

2. Navigate to the directory from your terminal and initialize Node with the  following command:

{{%code class=&#34;language-javascript&#34;%}}npm init{{%/code%}}

Follow the steps in the terminal and provide the required details.

3. Now, add the express module to your application using the {{%link href=&#34;https://www.npmjs.com/&#34; %}}npm{{%/link%}} package manager by executing the command:

{{%code class=&#34;language-javascript&#34;%}}npm install --save express{{%/code%}}

4. You can now add the logic you require in the application&#39;s code in the main file. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-javascript&#34;%}}const express = require(&#39;express&#39;)
const app = express()
app.all(&#39;/&#39;, (req, res) =&gt; {
    res.status(200).send(&#34;Hello World&#34;)
})
app.listen(process.env.X_ZOHO_CATALYST_LISTEN_PORT || 9000, () =&gt; {
    console.log(&#34;Server Started&#34;)
}){{%/code%}}

5. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack:** Node16

6. Ensure the main file, configuration files, and the node modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

7. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

8. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-javascript&#34;%}}node index.js{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Express with NPM"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/express-npm/"
service: "Serverless"
--------------------------------------------------------------------------------


# Express Framework With NPM

This example illustrates the steps to build a Node.js app with the Express framework, then configuring a {{%link href=&#34;https://www.npmjs.com/&#34; %}}Node Package Manager{{%/link%}} (npm) {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} in one of the configuration files through scripts. This application will be bundled and associated with an AppSail service, and deployed to the console, before you configure the startup command in the console.

1. Create a new folder in your local system for the Express app.

2. Navigate to the directory from your terminal and initialize Node with the  following command:

{{%code class=&#34;language-javascript&#34;%}}npm init{{%/code%}}

Follow the steps in the terminal and provide the required details.

3. Now, add the express module to your application using the npm package manager by executing the command:

{{%code class=&#34;language-javascript&#34;%}}npm install --save express{{%/code%}}

4. You can now add the logic you require in the application&#39;s code in the main file. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-javascript&#34;%}}const express = require(&#39;express&#39;)
const app = express()
app.all(&#39;/&#39;, (req, res) =&gt; {
    res.status(200).send(&#34;Hello World&#34;)
})
app.listen(process.env.X_ZOHO_CATALYST_LISTEN_PORT || 9000, () =&gt; {
    console.log(&#34;Server Started&#34;)
}){{%/code%}}


5. Open the {{%link href=&#34;https://docs.npmjs.com/cli/v9/configuring-npm/package-json&#34; %}}{{%badge%}}package.json{{%/badge%}}{{%/link%}} configuration file in the application&#39;s directory. Inside the {{%badge%}}scripts{{%/badge%}} key in the file, you must add a new key: {{%badge%}}start{{%/badge%}} and configure its value as: {{%badge%}}node index.js{{%/badge%}}. This defines the startup command for the application. You can then refer to this key while adding the startup command.

6. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack:** Node16

7. Ensure the main file, configuration files, and the node modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

8. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

9. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-javascript&#34;%}}npm start{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Hapi"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/hapi/"
service: "Serverless"
--------------------------------------------------------------------------------


# Hapi Framework

{{%link href=&#34;https://hapi.dev/&#34; %}}Hapi.js{{%/link%}} is a Node framework that helps you build scalable web applications, HTTP-proxy applications, APIs, and more. Hapi offers a robust plugin system, a comprehensive and integrated authentication architecture, end-to-end high security, and more.

This example illustrates the steps to build a simple Node.js app with the Hapi framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Hapi app.

2. Navigate to the directory from your terminal and initialize Node with the following command:

{{%code class=&#34;language-javascript&#34;%}}npm init{{%/code%}}

Follow the steps in the terminal and provide the required details.

3. Add the Hapi module to your application using {{%link href=&#34;https://www.npmjs.com/&#34; %}}npm{{%/link%}} by executing the command:

{{%code class=&#34;language-javascript&#34;%}}npm install --save @hapi/hapi{{%/code%}}

4. You can now add the logic you require in the application&#39;s code in the main file. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-javascript&#34;%}}&#39;use strict&#39;;
const Hapi = require(&#39;@hapi/hapi&#39;);
const init = async () =&gt; {
    const server = Hapi.server({
        port: process.env.X_ZOHO_CATALYST_LISTEN_PORT | 9000,
        host: &#39;0.0.0.0&#39;
    });
    server.route({
        method: &#39;GET&#39;,
        path: &#39;/&#39;,
        handler: (request, h) =&gt; {
            return &#39;Hello World!&#39;;
        }
    });
    await server.start();
    console.log(&#39;Server running on %s&#39;, server.info.uri);
};
process.on(&#39;unhandledRejection&#39;, (err) =&gt; {
    console.log(err);
    process.exit(1);
});
init();{{%/code%}}

5. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack:** Node16

6. Ensure the main file, configuration files, and the node modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

7. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

8. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-javascript&#34;%}}node index.js{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Koa"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/koa/"
service: "Serverless"
--------------------------------------------------------------------------------


# Koa Framework

{{%link href=&#34;https://koajs.com/&#34; %}}Koa{{%/link%}} is a Node.js middleware framework that is minimal and expressive in nature, and enables you to build robust web applications and APIs. Koa uses async functions that remove the need for callbacks, handles errors efficiently, and substantially reduces your time in building servers through a multitude of other features it offers.

This example illustrates the steps to build a simple Node.js app with the Koa framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Koa app.

2. Navigate to the directory from your terminal and initialize Node with the following command:

{{%code class=&#34;language-javascript&#34;%}}npm init{{%/code%}}

Follow the steps in the terminal and provide the required details.

3. Add the Koa module to your application using {{%link href=&#34;https://www.npmjs.com/&#34; %}}npm{{%/link%}} by executing the command:
	
{{%code class=&#34;language-javascript&#34;%}}npm install --save koa
npm install --save @koa/router{{%/code%}}

4. You can now add the logic you require in the application&#39;s code in the main file. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-javascript&#34;%}}var Koa = require(&#39;koa&#39;);
var Router = require(&#39;@koa/router&#39;);
const app = new Koa();
const router = new Router();
router.get(&#39;/&#39;, (ctx, next) =&gt; {
    ctx.body = &#34;Hello World&#34;
});
app.use(router.routes())
app.listen(process.env.X_ZOHO_CATALYST_LISTEN_PORT | 9000);{{%/code%}}

5. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack:** Node16

6. Ensure the main file, configuration files, and the node modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

7. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

8. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-javascript&#34;%}}node index.js{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.

--------------------------------------------------------------------------------
title: "Fastify"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/fastify/"
service: "Serverless"
--------------------------------------------------------------------------------


# Fastify

{{%link href=&#34;https://www.fastify.io/&#34; %}}Fastify{{%/link%}} is a high-performance, highly-extensible Node.js framework with minimal overhead, that helps you create reliable and efficient applications and APIs. Fastify brings in a host of convent features, such as affordable logging, Schema support, TypeScript-readiness, and various other developer-friendly features.

This example illustrates the steps to build a simple Node.js app with the Fastify framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Fastify app.

2. Navigate to the directory from your terminal and initialize Node with the following command:

{{%code class=&#34;language-javascript&#34;%}}npm init{{%/code%}}

Follow the steps in the terminal and provide the required details.

3. Add the Fastify framework to your application using {{%link href=&#34;https://www.npmjs.com/&#34; %}}npm{{%/link%}} by executing the command:

{{%code class=&#34;language-javascript&#34;%}}npm install --save fastify{{%/code%}}

4. You can now add the logic you require in the application&#39;s code in the main file. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-javascript&#34;%}}// Require the framework and instantiate it
const fastify = require(&#39;fastify&#39;)({ logger: true })
// Declare a route
fastify.get(&#39;/&#39;, async (request, reply) =&gt; {
  return { hello: &#39;world&#39; }
})
// Run the server!
const start = async () =&gt; {
  try {
    await fastify.listen({ 
        port: process.env.X_ZOHO_CATALYST_LISTEN_PORT | 9000 ,
        host: &#34;0.0.0.0&#34;
    })
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start(){{%/code%}}

5. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack:** Node16

6. Ensure the main file, configuration files, and the node modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

7. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

8. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-javascript&#34;%}}node index.js{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Restify"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.658Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/nodejs.md/restify/"
service: "Serverless"
--------------------------------------------------------------------------------


# Restify Framework

{{%link href=&#34;http://restify.com/&#34; %}}Restify{{%/link%}} is a Node.js framework that helps you build RESTful web services specifically with a focus on high performance, and provides features that facilitate optimal error handling, versioning, and semantics-support. Restify also offers router introspection, datastore support with popular SQLs, and many other additional conveniences.

This example illustrates the steps to build a simple Node.js app with the Restify framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Restify app.

2. Navigate to the directory from your terminal and initialize Node with the following command:

{{%code class=&#34;language-javascript&#34;%}}npm init{{%/code%}}

Follow the steps in the terminal and provide the required details.

3. Add the Restify framework to your application using {{%link href=&#34;https://www.npmjs.com/&#34; %}}npm{{%/link%}} by executing the command:

{{%code class=&#34;language-javascript&#34;%}}npm install --save restify{{%/code%}}

4. You can now add the logic you require in the application&#39;s code in the main file. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-javascript&#34;%}}var restify = require(&#39;restify&#39;);
var server = restify.createServer();
server.get(&#39;/&#39;, function respond(req, res, next) {
    res.send(&#39;hello world&#39;);
    next();
});
server.listen(process.env.X_ZOHO_CATALYST_LISTEN_PORT | 9000, &#39;0.0.0.0&#39;, function () {
    console.log(&#39;%s listening at %s&#39;, server.name, server.url);
});{{%/code%}}

5. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack:** Node16

6. Ensure the main file, configuration files, and the node modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

7. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

8. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-javascript&#34;%}}node index.js{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


### Python


--------------------------------------------------------------------------------
title: "Overview"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.659Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/python/overview/"
service: "Serverless"
--------------------------------------------------------------------------------


# Python

### Overview

Python is one of the leading and most in-demand programming languages in the world, used in a wide variety of domains for numerous applications. Python&#39;s popularity is reflected in the vast collection of frameworks available for the programming environment, which can be broadly grouped into full-stack frameworks, microframeworks, or asynchronous frameworks. Each group of frameworks, and each individual framework, serves specific requirements with their unique features and advantages.

Python frameworks are equipped with pre-written libraries, templates, plugins, and features upon which you can build your own code. Based on your application needs, you can opt for the right framework.

AppSail does not provide any templates for specific Python frameworks, and therefore does not contain any framework restrictions. You can build your app service using any Python technology that you prefer, and incorporate any libraries, plugins, extensions, or dependencies. You can then directly select a Python runtime while initializing the app service in the CLI, and deploy it to AppSail.

The Python help guide contains step-by-step instructions on building basic sample apps with some of its most popular frameworks, deploying these apps as AppSail services, and configuring {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup commands{{%/link%}} as required.


### Prerequisites

{{%link href=&#34;https://www.python.org/downloads/&#34; %}}Download{{%/link%}} and install Python on your local machine.


--------------------------------------------------------------------------------
title: "Flask"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.659Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/python/flask/"
service: "Serverless"
--------------------------------------------------------------------------------


# Flask App with zcatalyst-sdk

{{%link href=&#34;https://flask.palletsprojects.com/en/2.2.x/&#34; %}}Flask{{%/link%}} is a popular, lightweight microframework of Python that developers can use to build highly functional applications. It does not use any libraries or tools, but supports a wide range of extensions for a variety of functionalities. Flask comes with a fast and built-in debugger and development server, as well as offers secure cookies, Unicode support and more.

This example illustrates the steps to build a simple Python app with the Flask framework and Catalyst Python SDK. This application will then be bundled and associated with an AppSail service, and deployed to the console.

{{%note%}}{{%bold%}}Note:{{%/bold%}} Catalyst offers a built-in support for the Flask framework through the {{%link href=&#34;/en/sdk/python/v1/overview&#34; %}}Catalyst Python SDK{{%/link%}}. You can create {{%link href=&#34;/en/serverless/help/functions/introduction/&#34; %}}Catalyst serverless functions{{%/link%}} using this SDK package.{{%/note%}}

1. Create a new folder in your local system for the Flask app.

2. Navigate to the directory from your terminal and execute the following command to install Flask and the {{%link href=&#34;/en/sdk/python/v1/setup/#installing-the-sdk&#34;%}}Python {{%badge%}}zcatalyst-sdk{{%/badge%}}{{%/link%}}:

{{%code class=&#34;language-python&#34;%}}python3 -m pip install flask -t .
python3 -m pip install --pre zcatalyst-sdk -t . {{%/code%}}

3. You can now create your python index file and name it {{%badge%}}app.py{{%/badge%}} or anything of your choice. Add the logic you require in the application&#39;s code. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-python&#34;%}}import os
from flask import Flask, request
app = Flask(__name__)
@app.route(&#39;/&#39;)
def hello():
    return &#39;Hello, World!&#39;
@app.route(&#39;/sdk&#39;)
def sdk():
    try:
        import zcatalyst_sdk as zcatalyst
        app = zcatalyst.initialize(req=request)
        cache_resp = app.cache().segment().put(&#39;Key&#39;, &#39;value&#39;)
        return cache_resp, 200
    except Exception as e:
        return &#39;Got exception: &#39; &#43; repr(e)
if __name__ == &#39;__main__&#39;:
    listen_port = int(os.getenv(&#39;X_ZOHO_CATALYST_LISTEN_PORT&#39;, 9000))
    app.run(host=&#34;0.0.0.0&#34;, port=listen_port){{%/code%}}

4. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack**: Python_3_9

5. Ensure all the Python application files along with the {{%badge%}}flask{{%/badge%}} and {{%badge%}}zcatalyst-sdk{{%/badge%}} modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

6. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

7. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-python&#34;%}}python3 -u app.py{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Django"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.659Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/python/django/"
service: "Serverless"
--------------------------------------------------------------------------------


# Django Framework

{{%link href=&#34;https://www.djangoproject.com/&#34; %}}Django{{%/link%}} is a highly popular, full-stack, open-sourced framework of Python that includes all Python features by default. This high-level framework handles much of the intricacies of web development in a built-in manner, and allows developers to focus on the logic of their apps. Django also offers inherent support for commonly-used database systems and ORM support to map objects to tables, which facilitates easy data migration.

This example illustrates the steps to build a simple Python app with the Django framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Django app.

2. Navigate to the directory from your terminal and execute the following command to install Django:

{{%code class=&#34;language-python&#34;%}}python3 -m pip install django -t .{{%/code%}}

3. Create a {{%link href=&#34;https://docs.djangoproject.com/en/4.1/intro/tutorial01/#creating-a-project&#34; %}}Django project{{%/link%}} by executing the following command.

{{%code class=&#34;language-python&#34;%}}python3 -m django startproject mysite{{%/code%}}

{{%note%}}{{%bold%}}Note:{{%/bold%}} You will need to configure your AppSail domain in {{%badge%}}ALLOWED_HOSTS{{%/badge%}} as mentioned in {{%link href=&#34;https://docs.djangoproject.com/en/4.2/ref/settings/#allowed-hosts&#34; %}}this help section{{%/link%}}.{{%/note%}}

4. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack**: Python_3_9

5. Ensure all the Python application files along with the {{%badge%}}django{{%/badge%}} modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

6. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

7. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-python&#34;%}}sh -c &#39;python3 -u mysite/manage.py runserver 0.0.0.0:${X_ZOHO_CATALYST_LISTEN_PORT}&#39;{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Bottle"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.659Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/python/bottle/"
service: "Serverless"
--------------------------------------------------------------------------------


# Bottle Framework

{{%link href=&#34;https://bottlepy.org/docs/dev/&#34; %}}Bottle{{%/link%}} is a fast and simple microframework of Python for building APIs, small-scale personal applications without the requirement of any dependencies. Bottle comes with a host of features like a built-in development server, plugins for various databases, request-dispatching routing, and several utilities.

This example illustrates the steps to build a simple Python app with the Bottle framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Bottle app.

2. Navigate to the directory from your terminal and execute the following command to install Bottle:

{{%code class=&#34;language-python&#34;%}}python3 -m pip install bottle -t.{{%/code%}}

3. You can now create your python index file and name it {{%badge%}}app.py{{%/badge%}} or anything of your choice. Add the logic you require in the application&#39;s code. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-python&#34;%}}import os
import bottle
app = bottle.Bottle()
@app.route(&#39;/&#39;)
def hello():
    return &#34;Hello, World!&#34;
if __name__ == &#39;__main__&#39;:
    listen_port = int(os.getenv(&#39;X_ZOHO_CATALYST_LISTEN_PORT&#39;, 9000))
    bottle.run(app, host=&#39;0.0.0.0&#39;, port=listen_port){{%/code%}}

4. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack**: Python_3_9

5. Ensure all the Python application files along with the {{%badge%}}bottle{{%/badge%}} modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

6. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

7. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-python&#34;%}}python3 -u app.py{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "CherryPy"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.659Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/python/cherrypy/"
service: "Serverless"
--------------------------------------------------------------------------------


# CherryPy Framework

{{%link href=&#34;https://cherrypy.dev/&#34; %}}CherryPy{{%/link%}} is an open-source, minimalist microframework of Python used to build web applications similar to writing an object-oriented program. CherryPy offers a highly functional plugin system, built-in support for authentication, encoding, caching, multiple- HTTP servers, and more.

1. Create a new folder in your local system for the CherryPy app.

2. Navigate to the directory from your terminal and execute the following command to install CherryPy:

{{%code class=&#34;language-python&#34;%}}python3 -m pip install CherryPy -t.{{%/code%}}


3. You can now create your python index file and name it {{%badge%}}app.py{{%/badge%}} or anything of your choice. Add the logic you require in the application&#39;s code. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-python&#34;%}}import os
import cherrypy
class HelloWorld:
    @cherrypy.expose
    def index(self):
        return &#34;Hello, World!&#34;
if __name__ == &#34;__main__&#34;:
    listen_port = int(os.getenv(&#39;X_ZOHO_CATALYST_LISTEN_PORT&#39;, 9000))
    cherrypy.config.update({
        &#34;server.socket_host&#34;: &#34;0.0.0.0&#34;,
        &#34;server.socket_port&#34;: 9000
    })
    cherrypy.quickstart(HelloWorld()){{%/code%}}

4. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack**: Python_3_9

5. Ensure all the Python application files along with the {{%badge%}}cherrypy{{%/badge%}} modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

6. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

7. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-python&#34;%}}python3 -u app.py{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


--------------------------------------------------------------------------------
title: "Tornado"
description: "Catalyst AppSail is a fully-managed PaaS component of Catalyst Serverless that enables you to develop and deploy services in Java, Node.js, and Python in the cloud with ease, and manage your platform instances."
last_updated: "2026-03-18T07:41:08.659Z"
source: "https://docs.catalyst.zoho.com/en/serverless/help/appsail/help-guides/python/tornado/"
service: "Serverless"
--------------------------------------------------------------------------------


# Tornado Framework

{{%link href=&#34;https://www.tornadoweb.org/en/stable/&#34; %}}Tornado{{%/link%}} is a Python web framework and an asynchronous networking library that relies on non-blocking network I/O to serve web applications. This framework is therefore ideal for handling a large number of active server connections, such as in websockets. Tornado also offers built-in internalization, quick request execution, and many other features.

This example illustrates the steps to build a simple Python app with the Tornado framework. This application will then be bundled and associated with an AppSail service, and deployed to the console.

1. Create a new folder in your local system for the Tornado app.

2. Navigate to the directory from your terminal and execute the following command to install Tornado:

{{%code class=&#34;language-python&#34;%}}python3 -m pip install tornado -t.{{%/code%}}

3. You can now create your python index file and name it {{%badge%}}app.py{{%/badge%}} or anything of your choice. Add the logic you require in the application&#39;s code. Given below is a sample code for a basic &#34;Hello World&#34; program.

{{%code class=&#34;language-python&#34;%}}import os
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write(&#34;Hello, World!&#34;)
if __name__ == &#34;__main__&#34;:
    app = tornado.web.Application([
        (r&#34;/&#34;, MainHandler),
    ])
    listen_port = int(os.getenv(&#39;X_ZOHO_CATALYST_LISTEN_PORT&#39;, 9000))
    app.listen(listen_port, address=&#39;0.0.0.0&#39;)
    tornado.ioloop.IOLoop.current().start(){{%/code%}}

4. You can now {{%link href=&#34;/en/cli/v1/initialize-resources/initialize-appsail/&#34; %}}initialize an AppSail service{{%/link%}} in the same directory from the CLI or {{%link href=&#34;/en/cli/v1/add-appsail/&#34; %}}add it{{%/link%}} in an existing project directory. The app&#39;s source must be your application&#39;s directory. Provide the following value while initializing the app service:

    **Stack**: Python_3_9

5. Ensure all the Python application files along with the {{%badge%}}tornado{{%/badge%}} modules are present in the build directory you specify during initialization. Catalyst will automatically ZIP your app files during deployment to the remote console. 

6. {{%link href=&#34;/en/cli/v1/deploy-resources/deploy-appsail//&#34; %}}Deploy the app service{{%/link%}} to the console.   

7. You can then configure the {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#startup-commands&#34; %}}startup command{{%/link%}} given below from the console:

{{%code class=&#34;language-python&#34;%}}python3 -u app.py{{%/code%}}

You can also configure this in the {{%badge%}}app-config.json{{%/badge%}} file before deploying.

&lt;br&gt;

Access the deployed app service from its {{%link href=&#34;/en/serverless/help/appsail/key-concepts/appsail-execution/#custom-domain-url&#34; %}}endpoint URL{{%/link%}}.


---

## SDK — Java — AppSail

--------------------------------------------------------------------------------
title: "Implement SDK in AppSail"
description: "This page describes the method to implement Java SDK in an AppSail service for Catalyst-managed runtimes and avail Catalyst features within the application."
last_updated: "2026-03-18T07:41:08.676Z"
source: "https://docs.catalyst.zoho.com/en/sdk/java/v1/serverless/appsail/implement-sdk-in-appsail/"
service: "Serverless"
related:
- AppSail Help (/en/serverless/help/appsail/introduction)

--------------------------------------------------------------------------------


# Catalyst AppSail

{{%link href=&#34;/en/serverless/help/appsail/introduction/&#34; %}}Catalyst AppSail{{%/link%}} is a fully-managed, independent platform for deploying web services to the cloud with ease. You can either deploy your application directly as a Catalyst-managed runtime that supports specific runtimes of Java, Node.js, and Python, or an OCI-compliant container image of your application as a custom-runtime.

Catalyst enables you to implement Java SDK in your AppSail applications for {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtimes{{%/link%}}. AppSail supports frameworks of Java such as Embedded Jetty, Spring MVC, and Spring Boot. You can {{%link href=&#34;/en/serverless/help/appsail/help-guides/introduction/&#34; %}}access help guides{{%/link%}} for building sample apps in Java.

## Implement Java SDK in AppSail

You can implement the Catalyst Java SDK in the codebase of your AppSail service with ease. The steps to implement and initialize the Catalyst SDK for different API versions of Java servlets are demonstrated with sample codes below. 

In all cases, Catalyst requires you to implement the {{%badge%}}**AuthHeaderProvider**{{%/badge%}} interface from the Catalyst Java SDK package. The implementation defines the {{%badge%}}getHeader(){{%/badge%}} method that returns the value of the request header. You can then pass an object of the implementation class to the {{%badge%}}init(){{%/badge%}} method, to initialize the SDK.

### Java Servlet API versions &lt;=4


Sample code for Java applications that use Java servlets of API versions lesser than or equal to 4.0 ({{%badge%}}{{%link href=&#34;https://docs.oracle.com/javaee%2F7%2Fapi%2F%2F/javax/servlet/package-summary.html&#34;%}}javax.servlet{{%/link%}}{{%/badge%}}):

**Implementation Class:**


{{%code class=&#34;language-java&#34;%}}package com.zoho.catalyst.appsail.demo.utils;
import javax.servlet.http.HttpServletRequest;
import com.zc.auth.AuthHeaderProvider;
public class AuthProviderImpl implements AuthHeaderProvider {
 HttpServletRequest request;
 public AuthProviderImpl(HttpServletRequest request) {
  this.request = request;
 }
 @Override
 public String getHeaderValue(String key) {
  return request.getHeader(key);
 }
}
{{%/code%}}

&lt;br&gt;

**Initialization:**

{{%code class=&#34;language-json&#34;%}}AuthProviderImpl authProviderImpl = new AuthProviderImpl(req);
CatalystSDK.init(authProviderImpl){{%/code%}}

&lt;br&gt;


### Java Servlet API versions &gt;=5


Sample code for Java applications that use Java servlets of API versions greater than or equal to 5.0 ({{%badge%}}{{%link href=&#34;https://mvnrepository.com/artifact/jakarta.servlet&#34;%}}jakarta.servlet{{%/link%}}{{%/badge%}}):

**Implementation Class:**


{{%code class=&#34;language-java&#34;%}}import com.zc.auth.AuthHeaderProvider;
import jakarta.servlet.http.HttpServletRequest;
public class AuthProviderImpl implements AuthHeaderProvider {
    private HttpServletRequest request;
    AuthProviderImpl(HttpServletRequest request) {
        this.request = request;
    }
    @Override
    public String getHeaderValue(String s) {
        return request.getHeader(s);
    }
}{{%/code%}}

&lt;br&gt;

**Initialization:**

{{%code class=&#34;language-json&#34;%}}CatalystSDK.init(new AuthProviderImpl((HttpServletRequest) servletRequest));{{%/code%}}

&lt;br&gt;

### Implement Java SDK in a Maven Project

If you are developing a Java application with the {{%link href=&#34;https://maven.apache.org/&#34;%}}Maven{{%/link%}} build tool, you can include the Catalyst Java SDK as a dependency in the Maven configuration file ({{%link href=&#34;https://maven.apache.org/guides/introduction/introduction-to-the-pom.html&#34;%}}{{%badge%}}pom.xml{{%/badge%}}{{%/link%}}), instead of downloading and adding the SDK in your source code manually. 

To add the Catalyst SDK in a Maven project, simply add the Zoho repository (published in {{%link href=&#34;https://mvnrepository.com/&#34;%}}MvnRepository{{%/link%}}) in the {{%badge%}}pom.xml{{%/badge%}} file as shown below:


{{%code class=&#34;language-json&#34;%}}&amp;lt;repositories&amp;gt;
	&amp;lt;repository&amp;gt;
      &amp;lt;id&amp;gt;java-sdk&amp;lt;/id&amp;gt;
      &amp;lt;url&amp;gt;https://maven.zohodl.com&amp;lt;/url&amp;gt;
    &amp;lt;/repository&amp;gt;
  &amp;lt;/repositories&amp;gt;{{%/code%}}

You can then add the Java SDK as a dependency in pom.xml as shown below:
{{%code class=&#34;language-json&#34;%}}&amp;lt;dependencies&amp;gt;
    &amp;lt;dependency&amp;gt;
      &amp;lt;groupId&amp;gt;com.zoho.catalyst&amp;lt;/groupId&amp;gt;
      &amp;lt;artifactId&amp;gt;java-sdk&amp;lt;/artifactId&amp;gt;
      &amp;lt;version&amp;gt;1.15.0&amp;lt;/version&amp;gt;
    &amp;lt;/dependency&amp;gt;
 &amp;lt;/dependencies&amp;gt;{{%/code%}}


---

## SDK — Node JS — AppSail

--------------------------------------------------------------------------------
title: "Implement SDK in AppSail"
description: "This page describes the method to implement Node.js SDK in an AppSail service for Catalyst-managed runtimes and avail Catalyst features within the application.."
last_updated: "2026-03-18T07:41:08.677Z"
source: "https://docs.catalyst.zoho.com/en/sdk/nodejs/v2/serverless/appsail/implement-sdk-in-appsail/"
service: "Serverless"
related:
- AppSail Help (/en/serverless/help/appsail/introduction)

--------------------------------------------------------------------------------


# Catalyst AppSail

{{%link href=&#34;/en/serverless/help/appsail/introduction/&#34; %}}Catalyst AppSail{{%/link%}} is a fully-managed, independent platform for deploying web services to the cloud with ease. You can either deploy your application directly as a Catalyst-managed runtime that supports specific runtimes of Java, Node.js, and Python, or an OCI-compliant container image of your application as a custom-runtime.

Catalyst enables you to implement Node.js SDK in your AppSail applications for {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtimes{{%/link%}}. AppSail supports frameworks of Node.js such as React, Fastify, Express, etc. You can {{%link href=&#34;/en/serverless/help/appsail/help-guides/introduction/&#34; %}}access help guides{{%/link%}} for building sample apps in Node.js.

## Implement Node.js SDK in AppSail

You can implement the Catalyst Node.js SDK in the codebase of your AppSail service easily. You can install the Catalyst Node.js SDK package by executing the following command in your terminal and including it in your app&#39;s source code:

{{%code class=&#34;language-json&#34;%}}npm install zcatalyst-sdk-node --save{{%/code%}}

This will install the latest supported version of the Node.js SDK. You can also install a specific supported version in this way:

{{%code class=&#34;language-json&#34;%}}npm install zcatalyst-sdk-node@2.1.1 --save{{%/code%}}

You can then initialize the Node.js SDK in your application&#39;s code as shown in the sample code below. This passes the request object to the {{%badge%}}initialize(){{%/badge%}} method.

{{%code class=&#34;language-javascript&#34;%}}const catalyst = require(&#39;zcatalyst-sdk-node&#39;)
const express = require(&#39;express&#39;)
const app = express()
app.get((req, res) =&gt; {
let catalystApp = catalyst.initialize(req);
//Your code goes here 
})
app.listen(process.env(&#34;X_ZOHO_CATALYST_LISTEN_PORT&#34;) || 9000){{%/code%}}


Refer {{%link href=&#34;/en/sdk/nodejs/v2/overview/&#34;%}}Catalyst Node.js SDK help{{%/link%}} for details. The SDK documentation also provides sample code snippets for all supported functionalities.

&lt;br&gt;


---

## SDK — Python — AppSail

--------------------------------------------------------------------------------
title: "Implement SDK in AppSail"
description: "This page describes the method to implement Python SDK in an AppSail service for Catalyst-managed runtimes and avail Catalyst features within the application."
last_updated: "2026-03-18T07:41:08.677Z"
source: "https://docs.catalyst.zoho.com/en/sdk/python/v1/serverless/appsail/implement-sdk-in-appsail/"
service: "Serverless"
related:
- AppSail Help (/en/serverless/help/appsail/introduction)

--------------------------------------------------------------------------------


# Catalyst AppSail

{{%link href=&#34;/en/serverless/help/appsail/introduction/&#34; %}}Catalyst AppSail{{%/link%}} is a fully-managed, independent platform for deploying web services to the cloud with ease. You can either deploy your application directly as a Catalyst-managed runtime that supports specific runtimes of Java, Node.js, and Python, or an OCI-compliant container image of your application as a custom-runtime.

Catalyst enables you to implement Python SDK in your AppSail applications for {{%link href=&#34;/en/serverless/help/appsail/catalyst-managed-runtimes/key-concepts/&#34; %}}Catalyst-managed runtimes{{%/link%}}. AppSail supports frameworks of Python such as Flask, Django, Bottle, CherryPy, etc. You can {{%link href=&#34;/en/serverless/help/appsail/help-guides/introduction/&#34; %}}access help guides{{%/link%}} for building sample apps in Python. 

## Implement Python SDK in AppSail

You can implement the Catalyst Python SDK in the codebase of your AppSail service with ease. The SDK will need to be initialized with the request object before each request.  

Given below is an example of importing and initializing the Python SDK in a Flask web app.

{{%code class=&#34;language-python&#34; scroll=&#34;set-scroll&#34; %}}from flask import Flask, request, g
import os
import zcatalyst_sdk
from zcatalyst_sdk.catalyst_app import CatalystApp
app = Flask(__name__)
@app.before_request
def before_request():
    if request.path.startswith(&#39;/admin&#39;):
        return &#39;Unauthorized&#39;, 401
    # if authorized user
    g.zc_app = zcatalyst_sdk.initialize(req=request)
@app.route(&#39;/&#39;)
def index():
    return &#39;Web App with Python Flask!&#39;
@app.route(&#39;/cache&#39;)
def cache():
    app: CatalystApp = g.zc_app
    resp = app.cache().segment().put(&#39;key&#39;, &#39;value&#39;)
    return resp, 200
listen_port = os.getenv(&#39;X_ZOHO_CATALYST_LISTEN_PORT&#39;, 9000)
app.run(host=&#39;0.0.0.0&#39;, port = listen_port)
{{% /code%}} 

{{%note%}}{{%bold%}}Info :{{%/bold%}} Refer to the {{%link href=&#34;/en/sdk/python/v1/sdk-scopes&#34; %}}SDK Scopes table{{%/link%}} to determine the required permission level for performing the above operation.{{%/note%}}