--- metadata: - name: generator content: Diplodoc Platform v5.50.6 alternate: - https://ydb.tech/docs/en/recipes/ydb-sdk/balancing-prefer-location.md?version=main - https://ydb.tech/docs/ru/recipes/ydb-sdk/balancing-prefer-location.md?version=main sourcePath: en/core/recipes/ydb-sdk/balancing-prefer-location.md --- > **Documentation Index:** Fetch the complete configuration index at https://ydb.tech/docs/en/llms.txt # Prefer a specific availability zone Below are code examples for setting the "prefer availability zone" balancing algorithm option in different YDB SDKs. {% list tabs %} - C++ {% list tabs %} - Native SDK In the C++ SDK, you can select only one availability zone as the preferred one. ```cpp #include int main() { auto connectionString = std::string(std::getenv("YDB_CONNECTION_STRING")); auto driverConfig = NYdb::TDriverConfig(connectionString) .SetBalancingPolicy(NYdb::TBalancingPolicy::UsePreferableLocation("datacenter1")); NYdb::TDriver driver(driverConfig); // ... driver.Stop(true); return 0; } ``` - userver This functionality is not currently supported. {% endlist %} - Go {% list tabs %} - Native SDK ```go package main import ( "context" "os" "github.com/ydb-platform/ydb-go-sdk/v3" "github.com/ydb-platform/ydb-go-sdk/v3/balancers" ) func main() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() db, err := ydb.Open(ctx, os.Getenv("YDB_CONNECTION_STRING"), ydb.WithBalancer( balancers.PreferLocations( balancers.RandomChoice(), "a", "b", ), ), ) if err != nil { panic(err) } defer db.Close(ctx) // ... } ``` - database/sql Client-side balancing in the `database/sql` driver for YDB occurs only when establishing a new connection (in terms of `database/sql`), which represents a YDB session on a specific node. After the session is created, all queries on that session are sent to the node where the session was created. Balancing queries on the same YDB session across different nodes YDB does not happen. Code example for setting the "prefer availability zone" balancing algorithm: ```go package main import ( "context" "database/sql" "os" "github.com/ydb-platform/ydb-go-sdk/v3" "github.com/ydb-platform/ydb-go-sdk/v3/balancers" ) func main() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() nativeDriver, err := ydb.Open(ctx, os.Getenv("YDB_CONNECTION_STRING"), ydb.WithBalancer( balancers.PreferLocations( balancers.RandomChoice(), "a", "b", ), ), ) if err != nil { panic(err) } defer nativeDriver.Close(ctx) connector, err := ydb.Connector(nativeDriver) if err != nil { panic(err) } db := sql.OpenDB(connector) defer db.Close() // ... } ``` {% endlist %} - Python This functionality is not currently supported. - C# This functionality is not currently supported. - JavaScript This functionality is not currently supported. - Java In **Java SDK**, the availability zone preference is set in the gRPC transport settings. {% list tabs %} - Native SDK ```java import tech.ydb.common.transaction.TxMode; import tech.ydb.core.grpc.BalancingSettings; import tech.ydb.core.grpc.GrpcTransport; import tech.ydb.query.QueryClient; import tech.ydb.query.result.ResultSetReader; import tech.ydb.query.tools.QueryReader; import tech.ydb.query.tools.SessionRetryContext; import tech.ydb.table.query.Params; public class PreferLocationExample { public static void main(String[] args) { String connectionString = System.getenv().getOrDefault( "YDB_CONNECTION_STRING", "grpc://localhost:2136/local"); // Name of the preferred availability zone (e.g., VLA, SAS, MYT) String zone = System.getenv().getOrDefault("YDB_PREFER_LOCATION", "VLA"); try (GrpcTransport transport = GrpcTransport.forConnectionString(connectionString) .withBalancingSettings(BalancingSettings.fromLocation(zone)) .build(); QueryClient queryClient = QueryClient.newClient(transport).build()) { SessionRetryContext retryCtx = SessionRetryContext.create(queryClient).build(); QueryReader reader = retryCtx.supplyResult(session -> QueryReader.readFrom( session.createQuery("SELECT 1 AS value", TxMode.NONE, Params.empty()) )).join().getValue(); ResultSetReader rs = reader.getResultSet(0); if (rs.next()) { System.out.println("SELECT 1 = " + rs.getColumn("value").getInt32()); } } } } ``` - JDBC The `BalancingSettings.fromLocation()` equivalent is the `localDatacenter` property in the JDBC URL (see [JDBC driver properties](https://ydb.tech/docs/en/reference/languages-and-apis/jdbc-driver/properties.md?version=main)). ```java import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JdbcPreferLocationExample { public static void main(String[] args) throws SQLException { String jdbcUrl = System.getenv().getOrDefault( "YDB_JDBC_URL", "jdbc:ydb:grpc://localhost:2136/local"); // Name of the preferred availability zone (e.g., VLA, SAS, MYT) String zone = System.getenv().getOrDefault("YDB_PREFER_LOCATION", "VLA"); try (Connection connection = DriverManager.getConnection( jdbcUrl + (jdbcUrl.contains("?") ? "&" : "?") + "localDatacenter=" + zone); Statement statement = connection.createStatement(); ResultSet rs = statement.executeQuery("SELECT 1 AS value")) { if (rs.next()) { System.out.println("SELECT 1 = " + rs.getInt("value")); } } } } ``` In Spring Boot, ORM, and other third-party frameworks around JDBC, pass the same JDBC URL and availability zone parameters as for a direct connection (for example, in `spring.datasource.url` or pool properties). {% endlist %} - Rust This functionality is not currently supported. Track progress or vote for support in the Rust SDK: [ydb-rs-sdk#238](https://github.com/ydb-platform/ydb-rs-sdk/issues/238) - PHP This functionality is not currently supported. {% endlist %}