---
title: "Quick start"
url: "https://docs.yugabyte.com/stable/yugabyte-cloud/cloud-quickstart/distributed/"
---

# Quick start

Connect to a Distributed Postgres cluster in YugabyteDB Aeon and explore distributed SQL.

Connect to a Distributed Postgres cluster and explore distributed SQL

- [Free Serverless](/stable/yugabyte-cloud/cloud-quickstart/)
- [Distributed](/stable/yugabyte-cloud/cloud-quickstart/distributed/)

For multi-node, highly available YugabyteDB clusters, create a Distributed Postgres cluster. These are deployed across multiple nodes, zones, and regions, and are billed per vCPU.

Note that before you can create a distributed cluster in YugabyteDB Aeon, you need to [add your billing profile and payment method](/stable/yugabyte-cloud/cloud-admin/cloud-billing-profile/ "add your billing profile and payment method"), or you can [request a free trial](/stable/yugabyte-cloud/managed-freetrial/ "request a free trial").

1. If you haven't already, [Sign up](https://cloud.yugabyte.com/signup?utm_medium=direct&utm_source=docs&utm_campaign=YBM_signup "Sign up") and [Log in](https://cloud.yugabyte.com/login "Log in").
2. Click **Set Up Distributed**. (If you don't see the Set Up Distributed option, select the **Clusters** page, then click **Explore Cluster Types**.)
   
   This displays the **Create Distributed Cluster** wizard.
3. Follow the instructions to create your distributed cluster.
   
   For information on the distributed topologies you can create, refer to [Create distributed clusters](/stable/yugabyte-cloud/cloud-basics/create-clusters/ "Create distributed clusters").
4. Click **Create Cluster**.

The distributed cluster takes up to 5 minutes to deploy.

## Connect using Cloud Shell

Use Cloud Shell to connect to your Distributed Postgres cluster from your browser, and interact with it using distributed SQL.

To connect to your cluster, do the following:

1. On the **Clusters** page, ensure your cluster is selected.
2. Click **Connect** to display the **Connect to Cluster** dialog.
3. Under **Cloud Shell**, click **Launch Cloud Shell**.
4. Enter the database name (`yugabyte`), the user name (`admin`), select the YSQL API type, and click **Confirm**.
   
   Cloud Shell opens in a separate browser window. Cloud Shell can take up to 30 seconds to be ready.
   
   ```output
   Enter your DB password:
   ```
5. Enter the password for the admin user credentials that you saved when you created the cluster.
   
   The shell prompt appears and is ready to use.
   
   ```output
   ysqlsh (15.2-YB-2026.1.3.0-b0)
   SSL connection (protocol: TLSv1.2, cipher: ECDHE-RSA-AES256-GCM-SHA384, bits: 256, compression: off)
   Type "help" for help.
   
   yugabyte=>
   ```

Using Cloud Shell

Cloud Shell has a one hour connection limit. If your session is idle for more than 5 minutes, it may disconnect. If your session expires, close your browser tab and connect again.

The command line interface (CLI) being used is called [ysqlsh](/stable/api/ysqlsh/ "ysqlsh"). ysqlsh is the CLI for interacting with YugabyteDB using the PostgreSQL-compatible [YSQL API](/stable/api/ysql/ "YSQL API"). Cloud Shell also supports [ycqlsh](/stable/api/ycqlsh/ "ycqlsh"), a CLI for the [YCQL API](/stable/api/ycql/ "YCQL API").

For information on other ways to connect to your cluster, refer to [Connect to clusters](/stable/yugabyte-cloud/cloud-connect/ "Connect to clusters").

## Explore distributed SQL

When you connect to your cluster using Cloud Shell with the [YSQL API](/stable/api/ysql/ "YSQL API") (the default), the shell window incorporates a **Quick Start Guide**, with a series of pre-built queries for you to run. Follow the prompts to explore YugabyteDB in 5 minutes.

## Build an application

Applications connect to and interact with YugabyteDB using API client libraries (also known as client drivers). The tutorials in this section show how to connect applications to YugabyteDB Aeon clusters using your favorite programming language.

Before you begin, you need the following:

- a Distributed Postgres cluster deployed in YugabyteDB Aeon.
- the cluster CA certificate; YugabyteDB Aeon uses TLS to secure connections to the database.
- your computer added to the cluster IP allow list.

Refer to [Before you begin](/stable/develop/tutorials/build-apps/cloud-add-ip/ "Before you begin").

### Choose your language

- Java
- Go
- Python
- Node.js
- C
- C++
- C#
- Ruby
- Rust
- PHP

The [Java application](https://github.com/yugabyte/yugabyte-simple-java-app "Java application") connects to a YugabyteDB cluster using the topology-aware [Yugabyte JDBC driver](/stable/develop/drivers-orms/java/ "Yugabyte JDBC driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in Java.

The application requires the following:

- Java Development Kit (JDK) 1.8, or later, is installed. JDK installers for Linux and macOS can be downloaded from [Oracle](http://jdk.java.net/ "Oracle"), [Adoptium (OpenJDK)](https://adoptium.net/ "Adoptium (OpenJDK)"), or [Azul Systems (OpenJDK)](https://www.azul.com/downloads/?package=jdk "Azul Systems (OpenJDK)"). Homebrew users on macOS can install using `brew install openjdk`.
- [Apache Maven](https://maven.apache.org/index.html "Apache Maven") 3.3 or later.

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-java-app.git && cd yugabyte-simple-java-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `app.properties` file located in the application `src/main/resources/` folder.
   - Set the following configuration parameters:
     
     - **host** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **port** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **database** - the name of the database you are connecting to (the default is `yugabyte`).
     - **dbUser** and **dbPassword** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **sslMode** - the SSL mode to use; use `verify-full`.
     - **sslRootCert** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Build the application.
   
   ```sh
   $ mvn clean package
   ```
4. Start the application.
   
   ```sh
   $ java -cp target/yugabyte-simple-java-app-1.0-SNAPSHOT.jar SampleApp
   ```

If you are running the application on a free or single node cluster, the driver displays a warning that the load balance failed and will fall back to a regular connection.

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created DemoAccount table.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000

>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic Java application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/java/cloud-ysql-yb-jdbc/#explore-the-application-logic "Explore the application logic")

The [Go application](https://github.com/yugabyte/yugabyte-simple-go-app "Go application") connects to a YugabyteDB cluster using the [Go PostgreSQL driver](/stable/develop/drivers-orms/go/ "Go PostgreSQL driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in Go.

The application requires the following:

- [Go](https://go.dev/dl/ "Go") (tested with version 1.17.6).

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-go-app.git && cd yugabyte-simple-go-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.go` file.
   - Set the following configuration parameter constants:
     
     - **host** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **port** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **dbName** - the name of the database you are connecting to (the default is `yugabyte`).
     - **dbUser** and **dbPassword** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **sslMode** - the SSL mode to use; use `verify-full`.
     - **sslRootCert** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Initialize the `GO111MODULE` variable.
   
   ```sh
   $ export GO111MODULE=auto
   ```
4. Import the Go PostgreSQL driver.
   
   ```sh
   $ go get github.com/lib/pq
   ```
5. Start the application.
   
   ```sh
   $ go run sample-app.go
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic Go application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/go/cloud-ysql-go/#explore-the-application-logic "Explore the application logic")

The [Python application](https://github.com/yugabyte/yugabyte-simple-python-app "Python application") connects to a YugabyteDB cluster using the [Python psycopg2 PostgreSQL database adapter](/stable/develop/drivers-orms/python/ "Python psycopg2 PostgreSQL database adapter") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in Python.

The application requires the following:

- Python 3.6 or later (Python 3.9.7 or later if running macOS on Apple silicon).

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-python-app.git && cd yugabyte-simple-python-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.py` file.
   - Set the following configuration parameter constants:
     
     - **host** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **port** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **dbName** - the name of the database you are connecting to (the default is `yugabyte`).
     - **dbUser** and **dbPassword** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **sslMode** - the SSL mode to use; use `verify-full`.
     - **sslRootCert** - the full path to the YugabyteDB Aeon cluster CA certificate.
   - Save the file.
3. Install psycopg2 PostgreSQL database adapter.
   
   ```sh
   $ pip3 install psycopg2-binary
   ```
4. Start the application.
   
   ```sh
   $ python3 sample-app.py
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic Python application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/python/cloud-ysql-python/#explore-the-application-logic "Explore the application logic")

The [Node.js application](https://github.com/yugabyte/yugabyte-simple-node-app "Node.js application") connects to a YugabyteDB cluster using the [node-postgres driver](/stable/develop/drivers-orms/nodejs/ "node-postgres driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in Node.js.

The application requires the following:

- The latest version of [Node.js](https://nodejs.org/en/download/ "Node.js").

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-node-app.git && cd yugabyte-simple-node-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.js` file.
   - Set the following configuration parameter constants:
     
     - **host** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **port** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **database** - the name of the database you are connecting to (the default is `yugabyte`).
     - **user** and **password** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **ssl** - To enable `verify-ca` SSL mode, the `rejectUnauthorized` property is set to `true` to require root certificate chain validation; replace `path_to_your_root_certificate` with the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Install the node-postgres module.
   
   ```sh
   npm install pg
   ```
4. Install the [async](https://github.com/caolan/async "async") utility:
   
   ```sh
   npm install --save async
   ```
5. Start the application.
   
   ```sh
   $ node sample-app.js
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic Node.js application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/nodejs/cloud-ysql-node/#explore-the-application-logic "Explore the application logic")

The [C application](https://github.com/yugabyte/yugabyte-simple-c-app "C application") connects to a YugabyteDB cluster using the [libpq driver](/stable/develop/drivers-orms/ysql-client-drivers/#libpq "libpq driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in C.

The application requires the following:

- 32-bit (x86) or 64-bit (x64) architecture machine. (Use [Rosetta](https://support.apple.com/en-us/HT211861 "Rosetta") to build and run on Apple silicon.)
- gcc 4.1.2 or later, or clang 3.4 or later installed.
- OpenSSL 1.1.1 or later (used by libpq to establish secure SSL connections).
- [libpq](/stable/develop/drivers-orms/ysql-client-drivers/#libpq "libpq"). Homebrew users on macOS can install using `brew install libpq`. You can download the PostgreSQL binaries and source from [PostgreSQL Downloads](https://www.postgresql.org/download/ "PostgreSQL Downloads").

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-c-app.git && cd yugabyte-simple-c-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.c` file.
   - Set the following configuration-related macros:
     
     - **HOST** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **PORT** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **DB\_NAME** - the name of the database you are connecting to (the default is `yugabyte`).
     - **USER** and **PASSWORD** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **SSL\_MODE** - the SSL mode to use; use `verify-full`.
     - **SSL\_ROOT\_CERT** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Build the application with gcc or clang.
   
   ```sh
   gcc sample-app.c -o sample-app -I<path-to-libpq>/libpq/include -L<path-to-libpq>/libpq/lib -lpq
   ```
4. Replace `<path-to-libpq>` with the path to the libpq installation; for example, `/usr/local/opt`.
5. Start the application.
   
   ```sh
   $ ./sample-app
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic C application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/c/cloud-ysql-c/#explore-the-application-logic "Explore the application logic")

The [C++ application](https://github.com/yugabyte/yugabyte-simple-cpp-app "C++ application") connects to a YugabyteDB cluster using the [libpqxx driver](/stable/develop/drivers-orms/ysql-client-drivers/#libpqxx "libpqxx driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in C++.

The application requires the following:

- 32-bit (x86) or 64-bit (x64) architecture machine. (Use [Rosetta](https://support.apple.com/en-us/HT211861 "Rosetta") to build and run on Apple silicon.)
- gcc 4.1.2 or later, or clang 3.4 or later installed.
- OpenSSL 1.1.1 or later (used by libpq and libpqxx to establish secure SSL connections).
- [libpq](/stable/develop/drivers-orms/ysql-client-drivers/#libpq "libpq"). Homebrew users on macOS can install using `brew install libpq`. You can download the PostgreSQL binaries and source from [PostgreSQL Downloads](https://www.postgresql.org/download/ "PostgreSQL Downloads").
- [libpqxx](/stable/develop/drivers-orms/ysql-client-drivers/#libpqxx "libpqxx"). Homebrew users on macOS can install using `brew install libpqxx`. To build the driver yourself, refer to [Building libpqxx](https://github.com/jtv/libpqxx#building-libpqxx "Building libpqxx").

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-cpp-app.git && cd yugabyte-simple-cpp-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.cpp` file.
   - Set the following configuration-related constants:
     
     - **HOST** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **PORT** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **DB\_NAME** - the name of the database you are connecting to (the default is `yugabyte`).
     - **USER** and **PASSWORD** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **SSL\_MODE** - the SSL mode to use; use `verify-full`.
     - **SSL\_ROOT\_CERT** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Build the application with gcc or clang.
   
   ```sh
   g++ -std=c++17 sample-app.cpp -o sample-app -lpqxx -lpq \
   -I<path-to-libpq>/libpq/include -I<path-to-libpqxx>/libpqxx/include \
   -L<path-to-libpq>/libpq/lib -L<path-to-libpqxx>/libpqxx/lib
   ```
4. Replace `<path-to-libpq>` with the path to the libpq installation, and `<path-to-libpqxx>` with the path to the libpqxx installation; for example, `/usr/local/opt`.
5. Start the application.
   
   ```sh
   $ ./sample-app
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic C++ application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/cpp/cloud-ysql-cpp/#explore-the-application-logic "Explore the application logic")

The [C# application](https://github.com/yugabyte/yugabyte-simple-csharp-app "C# application") connects to a YugabyteDB cluster using the [Npgsql driver](/stable/develop/drivers-orms/csharp/ "Npgsql driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in C#.

The application requires the following:

- [.NET 6.0 SDK](https://dotnet.microsoft.com/en-us/download ".NET 6.0 SDK") or later.

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-csharp-app.git && cd yugabyte-simple-csharp-app
   ```
   
   The `yugabyte-simple-csharp-app.csproj` file includes the following package reference to include the driver:
   
   ```cpp
   <PackageReference Include="npgsql" Version="6.0.3" />
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.cs` file.
   - Set the following configuration-related parameters:
     
     - **urlBuilder.Host** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **urlBuilder.Port** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **urlBuilder.Database** - the name of the database you are connecting to (the default is `yugabyte`).
     - **urlBuilder.Username** and **urlBuilder.Password** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **urlBuilder.SslMode** - the SSL mode to use; use `SslMode.VerifyFull`.
     - **urlBuilder.RootCertificate** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Build and run the application.
   
   ```sh
   dotnet run
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic C# application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/csharp/cloud-ysql-csharp/#explore-the-application-logic "Explore the application logic")

The [Ruby application](https://github.com/yugabyte/yugabyte-simple-ruby-app "Ruby application") connects to a YugabyteDB cluster using the [Ruby Pg driver](/stable/develop/drivers-orms/ruby/ruby-pg/ "Ruby Pg driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in Ruby.

The application requires the following:

- Ruby 3.1 or later.
- OpenSSL 1.1.1 or later (used by libpq and pg to establish secure SSL connections).
- [libpq](/stable/develop/drivers-orms/ysql-client-drivers/#libpq "libpq"). Homebrew users on macOS can install using `brew install libpq`. You can download the PostgreSQL binaries and source from [PostgreSQL Downloads](https://www.postgresql.org/download/ "PostgreSQL Downloads").
- [Ruby pg](/stable/develop/drivers-orms/ruby/ruby-pg/ "Ruby pg"). To install Ruby pg, run the following command:
  
  ```sh
  gem install pg -- --with-pg-include=<path-to-libpq>/libpq/include --with-pg-lib=<path-to-libpq>/libpq/lib
  ```
  
  Replace `<path-to-libpq>` with the path to the libpq installation; for example, `/usr/local/opt`.

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-ruby-app.git && cd yugabyte-simple-ruby-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.rb` file.
   - Set the following configuration-related parameters:
     
     - **host** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **port** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **dbname** - the name of the database you are connecting to (the default is `yugabyte`).
     - **user** and **password** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **sslmode** - the SSL mode to use; use `verify-full`.
     - **sslrootcert** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Make the application file executable.
   
   ```sh
   chmod +x sample-app.rb
   ```
4. Run the application.
   
   ```sh
   $ ./sample-app.rb
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic Ruby application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/ruby/cloud-ysql-ruby/#explore-the-application-logic "Explore the application logic")

The [Rust application](https://github.com/yugabyte/yugabyte-simple-rust-app "Rust application") connects to a YugabyteDB cluster using the [Rust-Postgres driver](/stable/develop/drivers-orms/rust/yb-rust-postgres/ "Rust-Postgres driver") and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in Rust.

The application requires the following:

- [Rust](https://www.rust-lang.org/tools/install "Rust") development environment. The sample application was created for Rust 1.58 but should work for earlier and later versions.

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-rust-app.git && cd yugabyte-simple-rust-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.rs` file in the `src` directory.
   - Set the following configuration-related constants:
     
     - **HOST** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **PORT** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **DB\_NAME** - the name of the database you are connecting to (the default is `yugabyte`).
     - **USER** and **PASSWORD** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **SSL\_MODE** - the SSL mode to use; use `SslMode::Require`.
     - **SSL\_ROOT\_CERT** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Build and run the application.
   
   ```sh
   $ cargo run
   ```

The driver is included in the dependencies list of the `Cargo.toml` file and installed automatically the first time you run the application.

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic Rust application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/rust/cloud-ysql-rust/#explore-the-application-logic "Explore the application logic")

The [PHP application](https://github.com/yugabyte/yugabyte-simple-php-app "PHP application") connects to a YugabyteDB cluster using the [php-pgsql](/stable/develop/drivers-orms/php/ysql/ "php-pgsql") driver and performs basic SQL operations. Use the application as a template to get started with YugabyteDB in PHP.

The application requires the following:

- PHP runtime. The sample application was created using PHP 8.1 but should work with earlier and later versions. Homebrew users on macOS can install PHP using `brew install php`.
- [php-pgsql driver](/stable/develop/drivers-orms/php/ysql/ "php-pgsql driver").
  
  - On macOS, Homebrew automatically installs the driver with `brew install php`.
  - Ubuntu users can install the driver using the `sudo apt-get install php-pgsql` command.
  - CentOS users can install the driver using the `sudo yum install php-pgsql` command.

To build and run the application, do the following:

1. Clone the sample application to your computer:
   
   ```sh
   git clone https://github.com/YugabyteDB-Samples/yugabyte-simple-php-app.git && cd yugabyte-simple-php-app
   ```
2. Provide connection parameters.
   
   (You can skip this step and use the defaults if your cluster is running locally and listening on 127.0.0.1:5433.)
   
   The application needs to establish a connection to the YugabyteDB cluster. To do this:
   
   - Open the `sample-app.php` file.
   - Set the following configuration-related constants:
     
     - **HOST** - the host name of your YugabyteDB cluster. For local clusters, use the default (127.0.0.1). For YugabyteDB Aeon, select your cluster on the **Clusters** page, and click **Settings**. The host is displayed under **Connection Parameters**.
     - **PORT** - the port number for the driver to use (the default YugabyteDB YSQL port is 5433).
     - **DB\_NAME** - the name of the database to connect to (the default is `yugabyte`).
     - **USER** and **PASSWORD** - the username and password for the YugabyteDB database. For local clusters, use the defaults (`yugabyte`). For YugabyteDB Aeon, use the credentials in the credentials file you downloaded.
   - YugabyteDB Aeon [requires SSL connections](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/#ssl-modes-in-ysql "requires SSL connections"), so you need to set the following additional parameters:
     
     - **SSL\_MODE** - the SSL mode to use; use `verify-full`.
     - **SSL\_ROOT\_CERT** - the full path to the YugabyteDB Aeon [cluster CA certificate](/stable/yugabyte-cloud/cloud-secure-clusters/cloud-authentication/ "cluster CA certificate").
   - Save the file.
3. Run the application.
   
   ```sh
   $ php sample-app.php
   ```

You should see output similar to the following:

```output
>>>> Successfully connected to YugabyteDB!
>>>> Successfully created table DemoAccount.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 10000
name = John, age = 28, country = Canada, balance = 9000
>>>> Transferred 800 between accounts.
>>>> Selecting accounts:
name = Jessica, age = 28, country = USA, balance = 9200
name = John, age = 28, country = Canada, balance = 9800
```

You have successfully executed a basic PHP application that works with YugabyteDB.

[Explore the application logic](/stable/develop/tutorials/build-apps/php/cloud-ysql-php/#explore-the-application-logic "Explore the application logic")