Micronaut Oracle Cloud

https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/
Admin
This module provides integration between Micronaut and the Oracle Cloud Infrastructure (OCI) SDK,...
Tokens:28,945
Snippets:334
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Implement a BucketController

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Example controller implementation for interacting with Oracle Cloud Object Storage, provided in Java, Kotlin, and Groovy.

```java
import com.oracle.bmc.objectstorage.ObjectStorage;
import com.oracle.bmc.objectstorage.model.BucketSummary;
import com.oracle.bmc.objectstorage.model.CreateBucketDetails;
import com.oracle.bmc.objectstorage.model.ListObjects;
import com.oracle.bmc.objectstorage.model.ObjectSummary;
import com.oracle.bmc.objectstorage.requests.CreateBucketRequest;
import com.oracle.bmc.objectstorage.requests.DeleteBucketRequest;
import com.oracle.bmc.objectstorage.requests.GetNamespaceRequest;
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest;
import com.oracle.bmc.objectstorage.requests.ListObjectsRequest;
import org.jspecify.annotations.Nullable;
import io.micronaut.core.util.CollectionUtils;
import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Delete;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.PathVariable;
import io.micronaut.http.annotation.Post;
import io.micronaut.http.annotation.QueryValue;
import io.micronaut.oraclecloud.core.TenancyIdProvider;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

@Controller("/os")
public class BucketController {

    private final ObjectStorage objectStorage;
    private final TenancyIdProvider tenancyIdProvider;

    public BucketController(ObjectStorage objectStorage,
                            TenancyIdProvider tenancyIdProvider) { // (1)
        this.objectStorage = objectStorage;
        this.tenancyIdProvider = tenancyIdProvider;
    }
}
```

```kotlin
import com.oracle.bmc.objectstorage.ObjectStorage
import com.oracle.bmc.objectstorage.model.CreateBucketDetails
import com.oracle.bmc.objectstorage.requests.CreateBucketRequest
import com.oracle.bmc.objectstorage.requests.DeleteBucketRequest
import com.oracle.bmc.objectstorage.requests.GetNamespaceRequest
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest
import com.oracle.bmc.objectstorage.requests.ListObjectsRequest
import io.micronaut.core.annotation.Nullable
import io.micronaut.http.MediaType
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Delete
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.PathVariable
import io.micronaut.http.annotation.Post
import io.micronaut.http.annotation.QueryValue
import io.micronaut.oraclecloud.core.TenancyIdProvider
import java.util.Optional

@Controller("/os")
class BucketController(private val objectStorage: ObjectStorage,
                       private val tenancyIdProvider: TenancyIdProvider) { // (1)
}
```

```groovy
import com.oracle.bmc.objectstorage.ObjectStorage
import com.oracle.bmc.objectstorage.model.CreateBucketDetails
import com.oracle.bmc.objectstorage.model.ListObjects
import com.oracle.bmc.objectstorage.requests.CreateBucketRequest
import com.oracle.bmc.objectstorage.requests.DeleteBucketRequest
import com.oracle.bmc.objectstorage.requests.GetNamespaceRequest
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest
import com.oracle.bmc.objectstorage.requests.ListObjectsRequest
import groovy.transform.CompileStatic
import io.micronaut.core.annotation.Nullable
import io.micronaut.http.MediaType
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Delete
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.PathVariable
import io.micronaut.http.annotation.Post
import io.micronaut.http.annotation.QueryValue
import io.micronaut.oraclecloud.core.TenancyIdProvider

@CompileStatic
@Controller('/os')
class BucketController {

    private final ObjectStorage objectStorage
    private final TenancyIdProvider tenancyIdProvider

    BucketController(ObjectStorage objectStorage,
                     TenancyIdProvider tenancyIdProvider) { // (1)
        this.objectStorage = objectStorage
        this.tenancyIdProvider = tenancyIdProvider
    }
}
```

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

### Configure provider-map import

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Configuration examples for oraclecloud-vault provider-map settings across multiple supported formats.

```properties
micronaut.config.import[0].provider=oraclecloud-vault
micronaut.config.import[0].compartment-id=ocid1.compartment.oc1..
micronaut.config.import[0].ocid=ocid1.vault.oc1.phx..
micronaut.config.import[0].includes[0]=DB_.*
micronaut.config.import[0].includes[1]=API_.*
micronaut.config.import[0].excludes[0]=DB_LEGACY_PASSWORD
micronaut.config.import[0].retry-attempts=2
micronaut.config.import[0].retry-delay=10ms
```

```yaml
micronaut:
  config:
    import:
      - provider: oraclecloud-vault
        compartment-id: ocid1.compartment.oc1..
        ocid: ocid1.vault.oc1.phx..
        includes:
          - DB_.*
          - API_.*
        excludes:
          - DB_LEGACY_PASSWORD
        retry-attempts: 2
        retry-delay: 10ms
```

```toml
micronaut = {config = {import = [{provider = "oraclecloud-vault", compartment-id = "ocid1.compartment.oc1..", ocid = "ocid1.vault.oc1.phx..", includes = ["DB_.*", "API_.*"], excludes = ["DB_LEGACY_PASSWORD"], retry-attempts = 2, retry-delay = "10ms"}]}}
```

```groovy
micronaut {
  config {
    'import' = [{
        provider = "oraclecloud-vault"
        compartmentId = "ocid1.compartment.oc1.."
        ocid = "ocid1.vault.oc1.phx.."
        includes = ["DB_.*", "API_.*"]
        excludes = ["DB_LEGACY_PASSWORD"]
        retryAttempts = 2
        retryDelay = "10ms"
      }]
  }
}
```

```hocon
{
  micronaut {
    config {
      import = [{
          provider = "oraclecloud-vault"
          compartment-id = "ocid1.compartment.oc1.."
          ocid = "ocid1.vault.oc1.phx.."
          includes = ["DB_.*", "API_.*"]
          excludes = ["DB_LEGACY_PASSWORD"]
          retry-attempts = 2
          retry-delay = "10ms"
        }]
    }
  }
}
```

```json
{
  "micronaut": {
    "config": {
      "import": [{
          "provider": "oraclecloud-vault",
          "compartment-id": "ocid1.compartment.oc1..",
          "ocid": "ocid1.vault.oc1.phx..",
          "includes": ["DB_.*", "API_.*"],
          "excludes": ["DB_LEGACY_PASSWORD"],
          "retry-attempts": 2,
          "retry-delay": "10ms"
        }]
    }
  }
}
```

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

### Configure Oracle Cloud APM in Application Files

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Configuration examples for various file formats to enable Zipkin tracing with OCI APM endpoints.

```properties
micronaut.application.name=demo2
tracing.zipkin.enabled=true
tracing.zipkin.sampler.probability=1
tracing.zipkin.http.url=https://[redacted].apm-agt.us-phoenix-1.oci.oraclecloud.com
tracing.zipkin.http.path=/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=[public key]
tracing.zipkin.supportsJoin=false
```

```yaml
micronaut:
  application:
    name: demo2
tracing:
  zipkin:
    enabled: true
    sampler:
      probability: 1
    http:
      url: https://[redacted].apm-agt.us-phoenix-1.oci.oraclecloud.com
      path: /20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=[public key]
    supportsJoin: false
```

```toml
micronaut = {application = {name = "demo2"}}
tracing = {zipkin = {enabled = true, sampler = {probability = 1}, http = {url = "https://[redacted].apm-agt.us-phoenix-1.oci.oraclecloud.com", path = "/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=[public key]"}, supportsJoin = false}}
```

```groovy
micronaut {
  application {
    name = "demo2"
  }
}
tracing {
  zipkin {
    enabled = true
    sampler {
      probability = 1
    }
    http {
      url = "https://[redacted].apm-agt.us-phoenix-1.oci.oraclecloud.com"
      path = "/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=[public key]"
    }
    supportsJoin = false
  }
}
```

```hocon
{
  micronaut {
    application {
      name = "demo2"
    }
  }
  tracing {
    zipkin {
      enabled = true
      sampler {
        probability = 1
      }
      http {
        url = "https://[redacted].apm-agt.us-phoenix-1.oci.oraclecloud.com"
        path = "/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=[public key]"
      }
      supportsJoin = false
    }
  }
}
```

```json
{
  "micronaut": {
    "application": {
      "name": "demo2"
    }
  },
  "tracing": {
    "zipkin": {
      "enabled": true,
      "sampler": {
        "probability": 1
      },
      "http": {
        "url": "https://[redacted].apm-agt.us-phoenix-1.oci.oraclecloud.com",
        "path": "/20200101/observations/public-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=[public key]"
      },
      "supportsJoin": false
    }
  }
}
```

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

### Configure Managed Netty Client

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Example configuration for the managed Netty client in application.yml.

```yaml
oci:
  netty:
    legacy-netty-client: false
    use-managed-provider-globally: true
```

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

### Configure Proxy via System Properties

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Use these system properties to configure proxy settings for unmanaged Netty clients at application startup.

```bash
java -Dio.micronaut.oci.proxy=http://user:pass@proxy.example:8080 -jar app.jar
```

```bash
java \
 -Dio.micronaut.oci.proxy.host=proxy.acme.local \
 -Dio.micronaut.oci.proxy.port=3128 \
 -Dio.micronaut.oci.proxy.username=alice \
 -Dio.micronaut.oci.proxy.password=secret \
 -Dio.micronaut.oci.proxy.type=http \
 -Dio.micronaut.oci.proxy.nonProxyHosts="*.internal,localhost,127.0.0.1" \
 -jar app.jar
```

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

### Creating a Bucket Reactively

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Shows how to compose non-blocking operations to create an OCI bucket using the reactive client.

```java
@Override
@Post(value = "/buckets/{name}")
public Mono<String> createBucket(String name) {

    String compartmentId = defaultCompartmentId != null ? defaultCompartmentId : tenancyIdProvider.getTenancyId();

    GetNamespaceRequest getNamespaceRequest = GetNamespaceRequest.builder()
            .compartmentId(compartmentId).build();
    return objectStorage.getNamespace(getNamespaceRequest) // (1)
            .flatMap(namespaceResponse -> {
                CreateBucketRequest createBucketRequest = CreateBucketRequest.builder()
                        .namespaceName(namespaceResponse.getValue())
                        .createBucketDetails(CreateBucketDetails.builder()
                                .compartmentId(compartmentId)
                                .name(name)
                                .build())
                        .build();

                return objectStorage.createBucket(createBucketRequest) // (2)
                        .map(CreateBucketResponse::getLocation); // (3)
            });
}
```

```kotlin
@Post(value = "/buckets/{name}")
override fun createBucket(name: String): Mono<String> {
    val tenancyId = tenancyIdProvider.tenancyId
    val getNamespaceRequest = GetNamespaceRequest.builder()
            .compartmentId(tenancyId).build()
    return objectStorage.getNamespace(getNamespaceRequest) // (1)
            .flatMap { namespaceResponse: GetNamespaceResponse ->
                val createBucketRequest = CreateBucketRequest.builder()
                        .namespaceName(namespaceResponse.value)
                        .createBucketDetails(CreateBucketDetails.builder()
                                .compartmentId(tenancyId)
                                .name(name)
                                .build())
                        .build()
                objectStorage.createBucket(createBucketRequest) // (2)
                        .map { obj: CreateBucketResponse -> obj.location } // (3)
            }
}
```

```groovy
@Override
@Post(value = '/buckets/{name}')
Mono<String> createBucket(String name) {

    String tenancyId = tenancyIdProvider.tenancyId
    GetNamespaceRequest getNamespaceRequest = GetNamespaceRequest.builder()
            .compartmentId(tenancyId).build()
    return objectStorage.getNamespace(getNamespaceRequest) // (1)
            .flatMap(namespaceResponse -> {
                CreateBucketRequest createBucketRequest = CreateBucketRequest.builder()
                        .namespaceName(namespaceResponse.value)
                        .createBucketDetails(CreateBucketDetails.builder()
                                .compartmentId(tenancyId)
                                .name(name)
                                .build())
                        .build()

                return objectStorage.createBucket(createBucketRequest) // (2)
                        .map(CreateBucketResponse::getLocation) // (3)
            }) as Mono<String>
}
```

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

### WalletModule.instance()

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/atp/wallet/WalletModule.html

Retrieves the singleton instance of the WalletModule.

```APIDOC
## WalletModule.instance()

### Description
Retrieves the singleton instance of the WalletModule.

### Signature
`public static WalletModule instance()`

### Returns
- **WalletModule** - The singleton instance of the WalletModule.
```

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

### Create a new Function with Gradle

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Use the Micronaut CLI to initialize a new project with the oracle-function feature enabled for Gradle.

```bash
$ mn create-app myfunction --features oracle-function
```

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

### Create Oracle Function project with Maven

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Command to initialize a new Micronaut Oracle Function project using Maven.

```bash
$ mn create-function-app myfunction --build=maven --features oracle-function
```

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

### Configure Oracle Cloud Metrics

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Configuration settings for the Micrometer reporter using various formats.

```properties
micronaut.metrics.enabled=true
micronaut.metrics.export.oraclecloud.enabled=true
micronaut.metrics.export.oraclecloud.namespace=test
micronaut.metrics.export.oraclecloud.resourceGroup=foo
```

```yaml
micronaut:
  metrics:
    enabled: true
    export:
      oraclecloud:
        enabled: true
        namespace: test
        resourceGroup: foo
```

```toml
micronaut = {metrics = {enabled = true, export = {oraclecloud = {enabled = true, namespace = "test", resourceGroup = "foo"}}}}
```

```groovy
micronaut {
  metrics {
    enabled = true
    export {
      oraclecloud {
        enabled = true
        namespace = "test"
        resourceGroup = "foo"
      }
    }
  }
}
```

```hocon
{
  micronaut {
    metrics {
      enabled = true
      export {
        oraclecloud {
          enabled = true
          namespace = "test"
          resourceGroup = "foo"
        }
      }
    }
  }
}
```

```json
{
  "micronaut": {
    "metrics": {
      "enabled": true,
      "export": {
        "oraclecloud": {
          "enabled": true,
          "namespace": "test",
          "resourceGroup": "foo"
        }
      }
    }
  }
}
```

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

### loadWalletArchive(AutonomousDatabaseConfiguration autonomousDatabaseConfiguration)

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/atp/jdbc/OracleWalletArchiveProvider.html

Creates a wallet archive based on the provided AutonomousDatabaseConfiguration.

```APIDOC
## loadWalletArchive

### Description
Creates a wallet archive based on the provided `AutonomousDatabaseConfiguration`.

### Signature
`public CanConfigureOracleDataSource loadWalletArchive(AutonomousDatabaseConfiguration autonomousDatabaseConfiguration)`

### Parameters
- **autonomousDatabaseConfiguration** (AutonomousDatabaseConfiguration) - Required - The configuration object used to create the wallet archive.

### Returns
- **CanConfigureOracleDataSource** - The wallet archive instance.
```

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

### Configure Data Source Properties

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Set the required properties to enable automated data source configuration from the Wallet.

```properties
datasources.default.ocid=ocid1.autonomousdatabase.oc1.....
datasources.default.walletPassword=micronaut.1
datasources.default.username=foo
datasources.default.password=bar
```

```yaml
datasources:
  default:
    ocid: ocid1.autonomousdatabase.oc1.....
    walletPassword: micronaut.1
    username: foo
    password: bar
```

```toml
datasources = {default = {ocid = "ocid1.autonomousdatabase.oc1.....", walletPassword = "micronaut.1", username = "foo", password = "bar"}}
```

```groovy
datasources {
  'default' {
    ocid = "ocid1.autonomousdatabase.oc1....."
    walletPassword = "micronaut.1"
    username = "foo"
    password = "bar"
  }
}
```

```hocon
{
  datasources {
    default {
      ocid = "ocid1.autonomousdatabase.oc1....."
      walletPassword = "micronaut.1"
      username = "foo"
      password = "bar"
    }
  }
}
```

```json
{
  "datasources": {
    "default": {
      "ocid": "ocid1.autonomousdatabase.oc1.....",
      "walletPassword": "micronaut.1",
      "username": "foo",
      "password": "bar"
    }
  }
}
```

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

### Create Oracle Function project with Gradle

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Command to initialize a new Micronaut Oracle Function project using Gradle.

```bash
$ mn create-function-app myfunction --features oracle-function
```

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

### Configure SimpleAuthenticationDetailsProvider via Configuration Files

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Provides authentication details using various configuration formats supported by Micronaut.

```properties
oci.fingerprint=<value>
oci.passphrase=<value>
oci.private-key=<value>
oci.private-key-file=<value>
oci.region=<value>
oci.tenant-id=<value>
oci.user-id=<value>
```

```yaml
oci:
  fingerprint: <value>
  passphrase: <value>
  private-key: <value>
  private-key-file: <value>
  region: <value>
  tenant-id: <value>
  user-id: <value>
```

```toml
oci = {fingerprint = "<value>", passphrase = "<value>", private-key = "<value>", private-key-file = "<value>", region = "<value>", tenant-id = "<value>", user-id = "<value>"}
```

```groovy
oci {
  fingerprint = "<value>"
  passphrase = "<value>"
  privateKey = "<value>"
  privateKeyFile = "<value>"
  region = "<value>"
  tenantId = "<value>"
  userId = "<value>"
}
```

```hocon
{
  oci {
    fingerprint = "<value>"
    passphrase = "<value>"
    private-key = "<value>"
    private-key-file = "<value>"
    region = "<value>"
    tenant-id = "<value>"
    user-id = "<value>"
  }
}
```

```json
{
  "oci": {
    "fingerprint": "<value>",
    "passphrase": "<value>",
    "private-key": "<value>",
    "private-key-file": "<value>",
    "region": "<value>",
    "tenant-id": "<value>",
    "user-id": "<value>"
  }
}
```

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

### Enable SessionTokenAuthenticationDetailsProvider

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Configure the session token authentication provider using different configuration formats.

```properties
oci.config.session-token=true
```

```yaml
oci:
  config:
    session-token: true
```

```toml
oci = {config = {session-token = true}}
```

```groovy
oci {
  config {
    sessionToken = true
  }
}
```

```hocon
{
  oci {
    config {
      session-token = true
    }
  }
}
```

```json
{
  "oci": {
    "config": {
      "session-token": true
    }
  }
}
```

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

### Enable Instance Principal Authentication

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Configure the application to use Instance Principal authentication via different configuration formats.

```properties
oci.config.instance-principal.enabled=true
```

```yaml
oci:
  config:
    instance-principal:
        enabled: true
```

```toml
oci = {config = {instance-principal = {enabled = true}}}
```

```groovy
oci {
  config {
    instancePrincipal {
      enabled = true
    }
  }
}
```

```hocon
{
  oci {
    config {
      instance-principal {
        enabled = true
      }
    }
  }
}
```

```json
{
  "oci": {
    "config": {
      "instance-principal": {
        "enabled": true
      }
    }
  }
}
```

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

### Create a new Function with Maven

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Use the Micronaut CLI to initialize a new project with the oracle-function feature enabled for Maven.

```bash
$ mn create-app myfunction --build=maven --features oracle-function
```

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

### Add Reactive Client Support

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include dependencies for Reactor or RxJava 2 client support.

```gradle
implementation("io.micronaut.reactor:micronaut-reactor")
```

```maven
<dependency>
    <groupId>io.micronaut.reactor</groupId>
    <artifactId>micronaut-reactor</artifactId>
</dependency>
```

```gradle
implementation("io.micronaut.rxjava2:micronaut-rxjava2")
```

```maven
<dependency>
    <groupId>io.micronaut.rxjava2</groupId>
    <artifactId>micronaut-rxjava2</artifactId>
</dependency>
```

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

### Configure Logback for OCI

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Set up the OracleCloudAppender in your logback.xml file, ensuring the logId is correctly specified.

```xml
<configuration>

    <appender name="ORACLE" class="io.micronaut.oraclecloud.logging.OracleCloudAppender">
        <logId>ocid1.log.oc1.iad...</logId>
        <!-- <blackListLoggerName>example.app.Application</blackListLoggerName> -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.contrib.json.classic.JsonLayout">
                <jsonFormatter class="io.micronaut.oraclecloud.logging.OracleCloudJsonFormatter" />
            </layout>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="ORACLE" />
    </root>
</configuration>
```

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

### Create an Oracle Cloud Function

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Use the fn CLI to create a function from a container image stored in the Oracle Container Registry.

```bash
$ fn create function myapp myfunction [REGION].ocir.io/[TENANCY]/[REPOSITORY/[FUNCTION_NAME]:[FUNCTION_VERSION]

## For example:
$ fn create function myapp myfunction us-ashburn-1.ocir.io/mytenancy/myrepository/myfunction:1.0.0
```

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

### Configure OpenTelemetry Appender

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Update logback.xml to include the OpenTelemetryAppender for capturing trace information.

```xml
<configuration>

    <appender name="ORACLE" class="io.micronaut.oraclecloud.logging.OracleCloudAppender">
        <logId>ocid1.log.oc1.iad...</logId>
        <!-- <blackListLoggerName>example.app.Application</blackListLoggerName> -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.contrib.json.classic.JsonLayout">
                <jsonFormatter class="io.micronaut.oraclecloud.logging.OracleCloudJsonFormatter" />
            </layout>
        </encoder>
    </appender>

    <appender name="OTEL" class="io.opentelemetry.instrumentation.logback.v1_0.OpenTelemetryAppender">
        <appender-ref ref="ORACLE" />
    </appender>

    <root level="INFO">
        <appender-ref ref="OTEL" />
    </root>
</configuration>
```

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

### handleRequest

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/function/http/HttpFunction.html

The main entry point for processing Gateway functions for Project.fn.

```APIDOC
## handleRequest

### Description
Processes an incoming HTTP gateway request and returns an output event.

### Parameters
- **gatewayContext** (com.fnproject.fn.api.httpgateway.HTTPGatewayContext) - The gateway context.
- **inputEvent** (com.fnproject.fn.api.InputEvent) - The input event.

### Response
- **OutputEvent** (com.fnproject.fn.api.OutputEvent) - The resulting output event.
```

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

### Configure Oracle Cloud Registry in Gradle

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Update the dockerBuild and dockerBuildNative sections in build.gradle to point to the Oracle Cloud Registry.

```groovy
dockerBuild {
    images = ["[REGION].ocir.io/[TENANCY_ID]/[REPOSITORY]/$project.name:$project.version"]
}

dockerBuildNative {
    images = ["[REGION].ocir.io/[TENANCY_ID]/[REPOSITORY]/$project.name:$project.version"]
}
```

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

### Add micronaut-oraclecloud-httpclient-netty dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the Netty-based OCI SDK client implementation.

```gradle
implementation("io.micronaut.oraclecloud:micronaut-oraclecloud-httpclient-netty")
```

```maven
<dependency>
    <groupId>io.micronaut.oraclecloud</groupId>
    <artifactId>micronaut-oraclecloud-httpclient-netty</artifactId>
</dependency>
```

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

### WalletModule.wallets()

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/atp/wallet/WalletModule.html

Accesses the Wallets service from the WalletModule instance.

```APIDOC
## WalletModule.wallets()

### Description
Accesses the Wallets service.

### Signature
`public Wallets wallets()`

### Returns
- **Wallets** - The Wallets service instance.
```

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

### Configure Oracle Cloud Vault with Simple Authentication

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Use a connection string with user info and query parameters for simple authentication.

```Properties
micronaut.config.import[0]=oraclecloud-vault://tenant-user:secret@ocid1.compartment.oc1../ocid1.vault.oc1.phx..?tenant-id=ocid1.tenancy.oc1..&user-id=ocid1.user.oc1..&fingerprint=aa:bb:cc&private-key=/secrets/oci.pem
```

```Yaml
micronaut:
  config:
    import:
      - oraclecloud-vault://tenant-user:secret@ocid1.compartment.oc1../ocid1.vault.oc1.phx..?tenant-id=ocid1.tenancy.oc1..&user-id=ocid1.user.oc1..&fingerprint=aa:bb:cc&private-key=/secrets/oci.pem
```

```Toml
micronaut = {config = {import = ["oraclecloud-vault://tenant-user:secret@ocid1.compartment.oc1../ocid1.vault.oc1.phx..?tenant-id=ocid1.tenancy.oc1..&user-id=ocid1.user.oc1..&fingerprint=aa:bb:cc&private-key=/secrets/oci.pem"]}}
```

```Groovy
micronaut {
  config {
    'import' = ["oraclecloud-vault://tenant-user:secret@ocid1.compartment.oc1../ocid1.vault.oc1.phx..?tenant-id=ocid1.tenancy.oc1..&user-id=ocid1.user.oc1..&fingerprint=aa:bb:cc&private-key=/secrets/oci.pem"]
  }
}
```

```Hocon
{
  micronaut {
    config {
      import = ["oraclecloud-vault://tenant-user:secret@ocid1.compartment.oc1../ocid1.vault.oc1.phx..?tenant-id=ocid1.tenancy.oc1..&user-id=ocid1.user.oc1..&fingerprint=aa:bb:cc&private-key=/secrets/oci.pem"]
    }
  }
}
```

```JSON
{
  "micronaut": {
    "config": {
      "import": ["oraclecloud-vault://tenant-user:secret@ocid1.compartment.oc1../ocid1.vault.oc1.phx..?tenant-id=ocid1.tenancy.oc1..&user-id=ocid1.user.oc1..&fingerprint=aa:bb:cc&private-key=/secrets/oci.pem"]
    }
  }
}
```

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

### Configure legacy bootstrap-based distributed configuration

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Enable legacy bootstrap configuration for migration purposes. Note that this approach is deprecated.

```properties
micronaut.config-client.enabled=true
oci.vault.config.enabled=true
```

```yaml
micronaut:
  config-client:
    enabled: true
oci:
  vault:
    config:
      enabled: true
```

```toml
micronaut = {config-client = {enabled = true}}
oci = {vault = {config = {enabled = true}}}
```

```groovy
micronaut {
  configClient {
    enabled = true
  }
}
oci {
  vault {
    config {
      enabled = true
    }
  }
}
```

```hocon
{
  micronaut {
    config-client {
      enabled = true
    }
  }
  oci {
    vault {
      config {
        enabled = true
      }
    }
  }
}
```

```json
{
  "micronaut": {
    "config-client": {
      "enabled": true
    }
  },
  "oci": {
    "vault": {
      "config": {
        "enabled": true
      }
    }
  }
}
```

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

### Apply Oracle Database BOM

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Use the Oracle Database BOM to ensure compatible driver versions.

```gradle
implementation platform("com.oracle.database.jdbc:ojdbc-bom:23.26.1.0.0")
```

```maven
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.oracle.database.jdbc</groupId>
        <artifactId>ojdbc-bom</artifactId>
        <version>23.26.1.0.0</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
```

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

### Add OpenTracing Dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the Brave OpenTracing bridge to support OpenTracing APIs.

```gradle
implementation("io.opentracing.brave:brave-opentracing")
```

```maven
<dependency>
    <groupId>io.opentracing.brave</groupId>
    <artifactId>brave-opentracing</artifactId>
</dependency>
```

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

### Migrate Gradle Dependencies

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Regular expression for replacing standard OCI SDK Gradle dependencies with Micronaut-compatible versions.

```regex
com.oracle.oci.sdk:oci-java-sdk-([^:"')]+)
```

```regex
io.micronaut.oraclecloud:micronaut-oraclecloud-bmc-$1
```

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

### Configure OracleCloudAppender in logback.xml

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Defines the OracleCloudAppender with an emergency console appender reference and JSON formatting for OCI logs.

```xml
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <withJansi>true</withJansi>
        <!-- encoders are assigned the type
             ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
        <encoder>
            <pattern>%cyan(%d{HH:mm:ss.SSS}) %gray([%thread]) %highlight(%-5level) %magenta(%logger{36}) - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="ORACLE" class="io.micronaut.oraclecloud.logging.OracleCloudAppender">
        <appender-ref ref="STDOUT"/>
        <logId>ocid1.log.oc1.iad.amaaaaaabnqp5kqao2yjg6xymuql7w25otmcoylqgnqymwsh3gaxm2j3qgtza</logId>
        <blackListLoggerName>org.apache.http.impl.conn.PoolingHttpClientConnectionManager</blackListLoggerName>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.contrib.json.classic.JsonLayout">
                <jsonFormatter class="io.micronaut.oraclecloud.logging.OracleCloudJsonFormatter" />
            </layout>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="ORACLE" />
    </root>
</configuration>
```

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

### Add OpenTelemetry Logging Dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the OpenTelemetry Logback MDC dependency to enable trace and span ID tracking in logs.

```gradle
runtimeOnly("io.opentelemetry.instrumentation:opentelemetry-logback-mdc-1.0:1.16.0-alpha")
```

```maven
<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-logback-mdc-1.0</artifactId>
    <version>1.16.0-alpha</version>
    <scope>runtime</scope>
</dependency>
```

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

### read(Path path)

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/atp/wallet/Wallets.Archives.html

Reads a Wallet Archive from a file path containing at least a cwallet.sso file.

```APIDOC
## WalletArchive read(Path path)

### Description
Reads a Wallet Archive from the specified file path. The archive must contain at least a cwallet.sso file and optionally a tnsnames.ora file.

### Parameters
- **path** (Path) - Required - The path of the zip archive.

### Returns
- **WalletArchive** - The parsed WalletArchive instance.

### Throws
- **IOException** - If an error occurs reading the archive.
```

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

### Add micronaut-oraclecloud-common dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the common module for basic authentication and client configuration.

```gradle
implementation("io.micronaut.oraclecloud:micronaut-oraclecloud-common")
```

```maven
<dependency>
    <groupId>io.micronaut.oraclecloud</groupId>
    <artifactId>micronaut-oraclecloud-common</artifactId>
</dependency>
```

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

### Add OKE Kubernetes Client Dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the required dependency for the OKE Kubernetes client in your build configuration.

```Gradle
runtimeOnly("io.micronaut.oraclecloud:micronaut-oraclecloud-oke-kubernetes-client")
```

```Maven
<dependency>
    <groupId>io.micronaut.oraclecloud</groupId>
    <artifactId>micronaut-oraclecloud-oke-kubernetes-client</artifactId>
    <scope>runtime</scope>
</dependency>
```

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

### Add RxJava 2 Dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the RxJava 2 module to enable reactive support for Oracle Cloud SDK clients.

```Gradle
implementation("io.micronaut.rxjava2:micronaut-rxjava2")
```

```Maven
<dependency>
    <groupId>io.micronaut.rxjava2</groupId>
    <artifactId>micronaut-rxjava2</artifactId>
</dependency>
```

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

### beforeRequest(HttpRequest request)

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/httpclient/netty/OciNettyClientFilter.html

Executes logic before the OCI SDK client sends a request. Returns a context object that is passed to the afterResponse method.

```APIDOC
## beforeRequest

### Description
The OCI SDK client will execute this method before sending a request.

### Signature
`@NonNull R beforeRequest(@NonNull com.oracle.bmc.http.client.HttpRequest request)`

### Parameters
- **request** (com.oracle.bmc.http.client.HttpRequest) - The HTTP request being sent.

### Returns
- **R** (Object) - The context data that will be passed to the `afterResponse` method.
```

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

### Configure OKE Workload Identity

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Enable OKE Workload Identity authentication via application configuration files.

```properties
oci.config.oke-workload-identity.enabled=true
```

```yaml
oci:
  config:
    oke-workload-identity:
        enabled: true
```

```toml
oci = {config = {oke-workload-identity = {enabled = true}}}
```

```groovy
oci {
  config {
    okeWorkloadIdentity {
      enabled = true
    }
  }
}
```

```hocon
{
  oci {
    config {
      oke-workload-identity {
        enabled = true
      }
    }
  }
}
```

```json
{
  "oci": {
    "config": {
      "oke-workload-identity": {
        "enabled": true
      }
    }
  }
}
```

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

### Add Kubernetes OpenAPI Client Dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the required Kubernetes OpenAPI client dependency for your project.

```Gradle
implementation("io.micronaut.kubernetes:micronaut-kubernetes-client-openapi")
```

```Maven
<dependency>
    <groupId>io.micronaut.kubernetes</groupId>
    <artifactId>micronaut-kubernetes-client-openapi</artifactId>
</dependency>
```

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

### List Object Storage Buckets in a Compartment

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Uses the ObjectStorage client and TenancyIdProvider to retrieve and list bucket names. Requires the micronaut-oraclecloud-sdk module.

```Java
@Get("/buckets{/compartmentId}")
public List<String> listBuckets(@PathVariable @Nullable String compartmentId) {

    String compartmentOcid = compartmentId != null ? compartmentId : tenancyIdProvider.getTenancyId();

    GetNamespaceRequest getNamespaceRequest = GetNamespaceRequest.builder()
            .compartmentId(compartmentOcid).build();
    String namespace = objectStorage.getNamespace(getNamespaceRequest).getValue();

    ListBucketsRequest listBucketsRequest = ListBucketsRequest.builder()
            .namespaceName(namespace)
            .compartmentId(compartmentOcid)
            .build();

    return objectStorage.listBuckets(listBucketsRequest)
            .getItems()
            .stream()
            .map(BucketSummary::getName)
            .collect(Collectors.toList());
}
```

```Kotlin
@Get("/buckets{/compartmentId}")
fun listBuckets(@PathVariable @Nullable compartmentId: String?): List<String> {
    val compartmentOcid = compartmentId ?: tenancyIdProvider.tenancyId!!
    val getNamespaceRequest = GetNamespaceRequest.builder()
            .compartmentId(compartmentOcid).build()
    val namespace = objectStorage.getNamespace(getNamespaceRequest).value
    val listBucketsRequest = ListBucketsRequest.builder()
            .namespaceName(namespace)
            .compartmentId(compartmentOcid)
            .build()
    return objectStorage.listBuckets(listBucketsRequest).items
            .map { it.name }
}
```

```Groovy
@Get('/buckets{/compartmentId}')
List<String> listBuckets(@PathVariable @Nullable String compartmentId) {

    String compartmentOcid = compartmentId ?: tenancyIdProvider.tenancyId

    GetNamespaceRequest getNamespaceRequest = GetNamespaceRequest.builder()
            .compartmentId(compartmentOcid).build()
    String namespace = objectStorage.getNamespace(getNamespaceRequest).value

    ListBucketsRequest listBucketsRequest = ListBucketsRequest.builder()
            .namespaceName(namespace)
            .compartmentId(compartmentOcid)
            .build()

    return objectStorage.listBuckets(listBucketsRequest).items*.name
}
```

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

### Add SDK Serialization Processor

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the annotation processor to support importing OCI SDK clients not compiled with Micronaut.

```gradle
annotationProcessor("io.micronaut.oraclecloud:oraclecloud-serde-processor")
```

```maven
<annotationProcessorPaths>
    <path>
        <groupId>io.micronaut.oraclecloud</groupId>
        <artifactId>oraclecloud-serde-processor</artifactId>
    </path>
</annotationProcessorPaths>
```

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

### Add Brave Instrumentation Dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include Brave HTTP instrumentation for tracing outgoing and incoming requests.

```gradle
runtimeOnly("io.zipkin.brave:brave-instrumentation-http")
```

```maven
<dependency>
    <groupId>io.zipkin.brave</groupId>
    <artifactId>brave-instrumentation-http</artifactId>
    <scope>runtime</scope>
</dependency>
```

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

### Add micronaut-oraclecloud-micrometer dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the required module for Micrometer integration with OCI Monitoring.

```gradle
runtimeOnly("io.micronaut.oraclecloud:micronaut-oraclecloud-micrometer")
```

```maven
<dependency>
    <groupId>io.micronaut.oraclecloud</groupId>
    <artifactId>micronaut-oraclecloud-micrometer</artifactId>
    <scope>runtime</scope>
</dependency>
```

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

### Migrate Maven Dependencies

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Regular expression for replacing standard OCI SDK Maven dependencies with Micronaut-compatible versions.

```regex
<dependency>(\s*)<groupId>com.oracle.oci.sdk</groupId>(\s*)<artifactId>oci-java-sdk-([^<]+)</artifactId>(((?!</dependency>)[\s\S])+)</dependency>
```

```regex
<dependency>$1<groupId>io.micronaut.oraclecloud</groupId>$2<artifactId>micronaut-oraclecloud-bmc-$3</artifactId>$4</dependency>
```

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

### Add OCI SDK Jersey Client Dependencies

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include dependencies for using OCI SDK clients with a Jersey implementation.

```gradle
implementation("com.oracle.oci.sdk:oci-java-sdk-vault")
```

```maven
<dependency>
    <groupId>com.oracle.oci.sdk</groupId>
    <artifactId>oci-java-sdk-vault</artifactId>
</dependency>
```

```gradle
implementation("com.oracle.oci.sdk:oci-java-sdk-common-httpclient-jersey")
```

```maven
<dependency>
    <groupId>com.oracle.oci.sdk</groupId>
    <artifactId>oci-java-sdk-common-httpclient-jersey</artifactId>
</dependency>
```

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

### read(InputStream content)

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/io/micronaut/oraclecloud/atp/wallet/Wallets.Archives.html

Reads a Wallet Archive from an input stream containing at least a cwallet.sso file.

```APIDOC
## WalletArchive read(InputStream content)

### Description
Reads a Wallet Archive from the provided input stream. The archive must contain at least a cwallet.sso file and optionally a tnsnames.ora file.

### Parameters
- **content** (InputStream) - Required - The contents of the Wallet archive.

### Returns
- **WalletArchive** - The parsed WalletArchive instance.

### Throws
- **IOException** - If an error occurs reading the archive.
```

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

### Add OCI SDK Monitoring dependency

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Include the OCI SDK Monitoring module required for metric reporting.

```gradle
implementation("com.oracle.oci.sdk:oci-java-sdk-monitoring")
```

```maven
<dependency>
    <groupId>com.oracle.oci.sdk</groupId>
    <artifactId>oci-java-sdk-monitoring</artifactId>
</dependency>
```

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

### OracleCloudCertificateFetcher.retrieveCertificate()

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/api/index-all.html

Retrieves a certificate bundle from OCI.

```APIDOC
## OracleCloudCertificateFetcher.retrieveCertificate(String, Long, String)

### Description
Retrieves a certificate bundle (including private key) from OCI and converts it into a `CertificateEvent`.
```

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

### Injecting ObjectStorageReactorClient

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Demonstrates the injection of the reactive ObjectStorage client into a controller constructor.

```groovy
import com.oracle.bmc.objectstorage.model.CreateBucketDetails
import com.oracle.bmc.objectstorage.requests.CreateBucketRequest
import com.oracle.bmc.objectstorage.requests.DeleteBucketRequest
import com.oracle.bmc.objectstorage.requests.GetNamespaceRequest
import com.oracle.bmc.objectstorage.requests.ListBucketsRequest
import com.oracle.bmc.objectstorage.responses.CreateBucketResponse
import groovy.transform.CompileStatic
import io.micronaut.core.annotation.Nullable
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Delete
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.PathVariable
import io.micronaut.http.annotation.Post
import io.micronaut.oraclecloud.clients.reactor.objectstorage.ObjectStorageReactorClient
import io.micronaut.oraclecloud.core.TenancyIdProvider
import reactor.core.publisher.Mono

@CompileStatic
@Controller('/os')
class BucketController implements BucketOperations {

    private final ObjectStorageReactorClient objectStorage
    private final TenancyIdProvider tenancyIdProvider

    BucketController(ObjectStorageReactorClient objectStorage,
                     TenancyIdProvider tenancyIdProvider) { // (1)
        this.objectStorage = objectStorage
        this.tenancyIdProvider = tenancyIdProvider
    }
}
```

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

### Configure Logback for Oracle Cloud

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide

Define the OracleCloudAppender in your logback.xml to send logs to the OCI Logging service.

```xml
<configuration>

    <appender name="ORACLE" class="io.micronaut.oraclecloud.logging.OracleCloudAppender">
        <logId>ocid1.log.oc1.iad...</logId>
        <!-- <blackListLoggerName>example.app.Application</blackListLoggerName> -->
        <encoder class="ch.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.logback.contrib.json.classic.JsonLayout">
                <jsonFormatter class="io.micronaut.oraclecloud.logging.OracleCloudJsonFormatter" />
            </layout>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="ORACLE" />
    </root>
</configuration>
```

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

### Specify main class in Maven

Source: https://micronaut-projects.github.io/micronaut-oracle-cloud/latest/guide/index.html

Define the full class name and package of the function class in the pom.xml properties.

```xml
<exec.mainClass>com.mycompany.MyFunction</exec.mainClass>
```
Tokens:
Raw