Oracle 1z0-1084-25 Oracle Cloud Infrastructure 2025 Developer Professional Exam Practice Test

Explanation

Oracle Cloud Infrastructure (OCI) API Gateway supports various backend-types to handle incoming requests and route them to the appropriate backend service. However, "ORACLE_STREAMS_BACKEND" is not a valid backend-type in OCI API Gateway. "STOCK_RESPONSE_BACKEND" is a valid backend-type that allows you to configure static responses directly in the API Gateway without routing requests to any specific backend service. This can be useful for handling simple requests or returning predefined responses. "HTTP BACKEND" is another valid backend-type that enables routing requests to an HTTP backend service. "ORACLE_FUNCTIONS_BACKEND" is a valid backend-type that allows you to route requests to Oracle Functions, which are serverless functions that can be used to execute specific logic or operations. However, "ORACLE_STREAMS_BACKEND" is not a valid backend-type in OCI API Gateway. The API Gateway does not have native support for Oracle Streams as a backend service. Oracle Streams is a feature of Oracle Database that provides a publish-subscribe mechanism for data replication and distribution within an Oracle Database environment. It is not directly integrated as a backend service in OCI API Gateway.

Explanation

The option that will get you more information on the error when invoking Oracle Functions from your Cloud Shell session is: "DEBUG=1 fn invoke myapp myfunction". Setting the environment variable DEBUG=1 before invoking the function using the fn command allows you to enable debug mode, which provides more detailed information about the execution of the function. This can be useful for troubleshooting and understanding the root cause of the error. By using the command "DEBUG=1 fn invoke myapp myfunction", the function invocation will be executed with debug mode enabled, and additional debug information will be displayed in the console output. This information can include stack traces, detailed error messages, and other relevant details that can help identify and resolve the issue. Using the verbose option (--verbose) or debug option (--debug) with the fn command may also provide additional information, but the specific behavior may depend on the version and configuration of the fn CLI tool. While contacting Oracle support with the error message is always an option, enabling debug mode using the DEBUG=1 environment variable provides immediate access to more detailed information and can help in diagnosing and resolving the error more efficiently.

OCI Queue is a service for enabling asynchronous (decoupled) communication in a serverless manner3. Queue handles high-volume transactional data that requires independent processing without loss or duplication3. Queue supports ordering of messages within a queue by using the FIFO (first-in-first-out) delivery option3. Therefore, using a single queue to process all transactions ensures that all transactions are processed in order and that no transaction is lost. Verified References: Overview of Queue

Explanation

The correct answer is: Microservices are used for long running operations while serverless functions are used for short running operations. One of the key differences between microservices and serverless functions is the duration of their execution. Microservices are typically designed to handle long-running operations and may continuously run and process requests as part of a larger system. They are often deployed and managed as long-lived services. On the other hand, serverless functions are designed to handle short-lived operations or tasks that execute in response to specific events or triggers. They are event-driven and execute only when invoked, providing a lightweight and ephemeral computing model. Serverless functions are often used for executing small, isolated pieces of code without the need for managing infrastructure or scaling concerns. While both microservices and serverless functions can be stateless or stateful depending on the specific implementation, the key distinction lies in the typical duration and execution pattern of these components within an application architecture.

Explanation

The correct options are: A configured OCI API signing key pair: The API signing key pair is used for authentication and authorization to access OCI resources, including the OKE cluster. The private key should be configured on your local machine to authenticate API requests. An SSH key pair with the public key added to the cluster worker nodes: This is required for secure SSH access to the worker nodes in the OKE cluster. You need to generate an SSH key pair and add the public key to the cluster's worker node pool during cluster creation or update. Therefore, the correct options are having a configured OCI API signing key pair and an SSH key pair with the public key added to the cluster worker nodes.

Explanation

The correct answers are: Amount of RAM used by a function: Oracle Functions collects and reports the amount of memory (RAM) used by a function during its execution. This metric helps in monitoring and optimizing the resource consumption of functions. Length of time a function runs: Oracle Functions captures and provides the duration of function executions. This metric allows you to track the performance and responsiveness of your functions and identify any potential bottlenecks or delays. These metrics provide valuable insights into the resource utilization and performance of your functions, enabling you to monitor and optimize their behavior in the Oracle Cloud Infrastructure (OCI) environment.

Explanation

The term that describes developing microservices in different languages of choice is "Polyglot." In a polyglot architecture, each microservice is developed using the most appropriate programming language or technology stack for its specific requirements. This approach allows developers to leverage the strengths of different languages and frameworks, enabling them to use the most suitable tool for each microservice while still maintaining interoperability between services.

Explanation

The correct answer is: "A finely tuned piece of software that performs a single or small collection of tasks." Microservices are a software architectural approach where a system is decomposed into small, independent services that are responsible for performing a specific set of tasks. Each microservice is designed to be focused, finely tuned, and highly cohesive, handling a single or a small collection of related tasks. This granularity allows for better scalability, maintainability, and flexibility in building complex applications. The other options provided do not accurately define microservices: An open-source system for automating deployment, scaling, and management of containerized applications refers to a container orchestration tool like Kubernetes, which can be used to manage microservices but is not a definition of microservices itself. A statically typed and compiled language describes a type of programming language characteristic and is not specific to the concept of microservices. An organized collection of structured information or data, typically stored electronically in a computer system is a definition of a database or data storage system and is unrelated to microservices.

Explanation

The two characteristics of microservices are: Microservices can be independently deployed: One of the key principles of microservices architecture is the ability to independently deploy each microservice. This means that changes or updates to one microservice can be made and deployed without affecting other microservices. It allows for faster and more frequent deployments, enabling agile development and scalability. Microservices communicate over lightweight APIs: Microservices communicate with each other through lightweight APIs (Application Programming Interfaces). This enables loose coupling between microservices, as they can interact with each other using standard protocols like HTTP/REST or messaging systems like RabbitMQ or Kafka. Lightweight APIs facilitate flexibility and interoperability between microservices, making it easier to develop and maintain complex systems. The remaining statement, "All microservices share a data store," is not a characteristic of microservices. Microservices are designed to be autonomous and have their own data storage or database. Each microservice has its own data store, which promotes the principle of bounded contexts and avoids tight coupling between services. This allows for better scalability and independence of data management within each microservice.

Explanation

The option that is NOT available when viewing the Application metrics in the Oracle Cloud Infrastructure (OCI) Console is: "The number of retries made by the function before failing due to an error." When viewing the Application metrics in the OCI Console for Oracle Functions, you can typically see metrics related to the performance and usage of your functions. These metrics provide insights into how your functions are performing and being utilized. The following metrics are usually available: The number of requests to invoke a function that failed due to throttling: This metric indicates the number of requests that were not processed by the function due to reaching the configured concurrency limit or throttling settings. The length of time a function runs for: This metric represents the duration of each function invocation, measuring the time it takes for the function to complete its execution. The number of requests to invoke a function that failed with an error response: This metric counts the number of requests that encountered an error during the function invocation, resulting in a failed response. However, the number of retries made by the function before failing due to an error is not typically available as part of the Application metrics in the OCI Console. The retries made by the function are usually handled at the invoker level, and the specific details of retries may not be captured as part of the application-level metrics. It's important to note that the availability of metrics and their specific details may vary depending on the version and configuration of Oracle Functions and the monitoring setup. It is recommended to refer to the Oracle Functions documentation and consult the official documentation for accurate and up-to-date information on available metrics.

Explanation

The two "Action Type" options that are NOT available in an Oracle Cloud Infrastructure (OCI) Events rule definition are: Email (Correct) Slack (Correct) The available "Action Type" options in OCI Events rule definition include Functions, Notifications, and Streaming. However, email and Slack are not directly supported as action types in OCI Events. Instead, you can use Notifications to send notifications to various notification channels, including email and Slack, through the OCI Notifications service.

The best way to store and use secret information, such as database passwords, in Oracle Functions is to use the OCI Vault service. The OCI Vault service provides encryption and decryption capabilities for sensitive data. You can use the OCI Vault service to encrypt the password and store it as an application-level configuration variable. Then, you can use the generated key to decrypt the password in your function code when you need to access the database. Verified References: Oracle Functions: Using Key Management To Encrypt And Decrypt Configuration Variables

Explanation

The valid statements regarding the OCI Container Engine for Kubernetes (OKE) service are: OKE automatically creates and configures new network resources for the new cluster. When creating a new OKE cluster, the service automatically provisions and configures the necessary network resources, such as VCNs, subnets, route tables, security lists, and load balancers, to support the cluster. Your tenancy must have sufficient quota on different types of resources. Before creating an OKE cluster, you need to ensure that your Oracle Cloud Infrastructure (OCI) tenancy has sufficient quota for the required resources, such as compute instances, block storage, networking resources, and load balancers. You must have access to an Oracle Cloud Infrastructure tenancy. To use the OKE service, you need to have access to an OCI tenancy. This means you must have a valid OCI account and the necessary permissions to create and manage resources within the tenancy. The following statements are not valid: OKE cannot use existing network resources for the creation of a new cluster. OKE creates new network resources specifically for the cluster, and it does not support using existing network resources. There is a limit of three clusters within each region, but there is no limit on the number of nodes and pods you can create within each cluster. This statement is incorrect. There is no specific limit on the number of clusters you can create within a region in OKE. However, there may be certain limits or quotas on resources that can impact the number of clusters you can create.

Explanation

The strategy that involves exposing new functionality or features to only a small set of users is called Canary Deployment. Canary deployment is a technique used in software development and deployment where a new version of an application or feature is released to a small subset of users or a specific group of servers. This allows for testing and gathering feedback on the new functionality in a controlled and limited environment before making it available to a wider audience. In a canary deployment, a small portion of the traffic is routed to the new version while the majority of the traffic still goes to the stable version. This allows for monitoring and evaluation of the new functionality in real-world conditions while minimizing the impact of any potential issues or bugs. If the new version performs well and meets the desired criteria, it can then be gradually rolled out to a larger user base or all servers. By exposing the new functionality or features to a small set of users initially, canary deployment helps in identifying any unforeseen issues, gathering feedback, and ensuring the stability and reliability of the application before a full deployment.

Explanation

To troubleshoot issues in OCI, the option that is not valid is: Trace performance issues in the Application Performance Monitoring service by enabling Function traces. While the Application Performance Monitoring service in OCI allows you to monitor and trace the performance of your applications, it is specifically designed for monitoring OCI Functions (serverless functions) and does not directly apply to all types of applications. The other options mentioned, such as configuring logs in the OCI Logging service, leveraging OCI Cloud Guard for debug logs, viewing service metrics in the OCI Monitoring service, and using OCI Service Connector Hub for log forwarding, are valid options for troubleshooting and monitoring applications in OCI.

Explanation

The correct value for the "type" field in the API deployment specification is "STOCK_RESPONSE_BACKEND". By setting the "type" to "STOCK_RESPONSE_BACKEND", you are indicating that the backend for the specified route should return a pre-defined response. This type of backend is commonly used when you want a specific response to be returned consistently, regardless of the actual backend service implementation. In this case, the API deployment specification is configured to have a single route with the path "/hello" and the method "GET". The backend section specifies the type as "STOCK_RESPONSE_BACKEND". Additionally, it defines the response status code as 200, sets the "Content-Type" header to "application/json", and provides the JSON content in the "body" field. Using this configuration, any request to the "/hello" path with the "GET" method will always receive a consistent JSON response with the content "{"myjson": "consistent response"}".

To pull a Docker image from OCI Registry to the client machine, you need to use the docker pull command with the following syntax1: docker pull .ocir.io//: where:

is the key for the OCI Registry region you’re using. For example, iad. See Availability by Region1.

ocir.io is the OCI Registry name.

is the auto-generated Object Storage namespace string of the tenancy that owns the repository from which you want to pull the image (as shown on the Tenancy Information page)1.

is the name of the repository that contains the image you want to pull.

is the tag of the image you want to pull.

Explanation

To provision storage buckets as part of your Kubernetes deployment process for an application that depends on Oracle Cloud Infrastructure (OCI) Object Storage, you should leverage the OCI Service Broker for Kubernetes. OCI Service Broker for Kubernetes enables you to provision and manage OCI resources, including Object Storage buckets, directly from Kubernetes. It provides a Kubernetes-native experience for managing OCI services, allowing you to define and manage OCI resources as part of your application deployment process. By using the OCI Service Broker for Kubernetes, you can define the required Object Storage buckets in your Kubernetes manifests, and the service broker will handle the provisioning and management of those buckets in OCI, ensuring that they are available for your application wherever it is running.

Explanation

The correct answer is: "A unique OCID is automatically generated for each secret and remains unchanged even when creating a new secret version." The statement that is NOT valid about managing secrets in the OCI Vault service is: "A unique OCID is automatically generated for each secret and remains unchanged even when creating a new secret version." In OCI Vault, a secret is identified by its OCID (Oracle Cloud Identifier), which is a unique identifier for each resource in Oracle Cloud Infrastructure. However, when a new secret version is created for an existing secret, the OCID remains the same for the secret itself, but a new OCID is generated for the secret version. This allows you to track and manage different versions of a secret while maintaining a consistent OCID for the secret itself. The other statements mentioned are valid: You can manually create new secrets as well as new secret versions using the OCI Console. This means you have control over creating and managing secrets within the Vault service. A secret reuse rule prevents the use of secret contents across different versions of a secret. This ensures that each secret version maintains its own unique set of contents and avoids accidental reuse or sharing of secrets across versions. By default, new secret versions automatically expire in 90 days unless you configure an expiry rule. This helps enforce good security practices by automatically rotating secrets periodically, reducing the risk of unauthorized access in case of compromise. Therefore, the statement that is NOT valid is the one regarding the uniqueness and consistency of the OCID when creating new secret versions.

Explanation

The Fn Project is an open source serverless computing platform that serves as the engine for Oracle Functions. It provides a runtime environment for executing functions in a serverless architecture. The Fn Project enables developers to build and deploy functions using different programming languages, including Java, Python, Node.js, and more. The Fn Project is designed to be flexible and extensible, allowing developers to define functions as small units of code and execute them in response to events or triggers. It supports event-driven execution, allowing functions to be triggered by various events such as HTTP requests, messages from messaging systems, or changes in data. Oracle Functions leverages the Fn Project as its underlying engine, providing a managed serverless platform within the Oracle Cloud Infrastructure. It allows developers to easily develop, deploy, and manage functions using the familiar Fn Project framework and tooling. With Oracle Functions, developers can focus on writing their function code while leaving the infrastructure management, scaling, and operational tasks to the platform.

Explanation

The correct answer is: fn deploy --app travel-app --all Explanation: To build and deploy multiple Oracle Functions as part of a single application named "travel-app," you can use the fn deploy command with the appropriate options. The command fn deploy --app travel-app --all is the correct syntax. Here's what each part of the command does: fn deploy: This command is used to deploy functions and applications in Oracle Functions. --app travel-app: This option specifies the application name as "travel-app," indicating that you want to deploy functions to this application. --all: This option indicates that you want to deploy all the functions within the application. By using fn deploy --app travel-app --all, you can build and deploy all the functions in your travel application across different programming languages (Java, Python, and Node.js) to the "travel-app" application in Oracle Functions.

OCI API Gateway supports the following authentication methods for accessing an API deployment3:

HTTP Basic: The client sends a username and password with each request. The credentials are validated against a user database in Oracle Identity Cloud Service (IDCS).

API Key: The client sends an API key with each request. The API key is validated against a list of keys stored in IDCS or OCI Vault.

OAuth: The client obtains an access token from an authorization server (such as IDCS) and sends it with each request. The access token is validated against the authorization server and optionally checked for required scopes.

JWT Token: The client obtains a JSON Web Token (JWT) from an identity provider (such as IDCS or OCI IAM) and sends it with each request. The JWT is validated against the identity provider’s public key and optionally checked for required claims. SAML Token is not a valid authentication method for accessing an OCI API Gateway deployment. SAML is an XML-based standard for exchanging authentication and authorization data between different parties, such as a service provider and an identity provider4. SAML tokens are typically used for web browser single sign-on (SSO) scenarios, not for API access4.

Idle-timeout is the parameter that is used to configure the time period during which an idle function will remain in memory before Oracle Functions removes its container image from memory2. The idle-timeout parameter is specified in seconds and can be set when creating or updating a function2. The default value for idle-timeout is 30 seconds and the maximum value is 900 seconds (15 minutes)2. If a function has the --provisioned-concurrency option enabled, the idle-timeout parameter is ignored and the function instances are always kept in memory3. Verified References: Creating Functions, Provisioned Concurrency

Explanation

To obtain a log file from one of the nodes in an Oracle Cloud Infrastructure (OCI) Container Engine for Kubernetes (OKE) cluster, you should SSH into the nodes using the private key. Here's the step-by-step process: Obtain the private key: The private key is required to authenticate and access the nodes in the OKE cluster. You should obtain the private key from your administrator or the appropriate key pair used to create the cluster. SSH into the node: Use a secure shell (SSH) client, such as OpenSSH, to connect to the desired node in the cluster. The SSH command typically includes the private key file path and the public IP address or hostname of the node. Example command: ssh -i opc@ Replace with the path to the private key file and with the public IP address of the node you want to access. Navigate to the log file location: Once you have successfully connected to the node, navigate to the directory where the log file is located. The exact location and name of the log file may vary depending on the Kubernetes distribution and configuration. Copy or view the log file: You can either copy the log file from the node to your local machine using the scp command or view the contents directly on the node using tools like cat or less. By following these steps, you will be able to access the log file from the desired node in the OKE cluster for troubleshooting purposes.

To prevent images from being deleted from a repository, you can set the global policy of image retention to “Retain All Images”. This policy applies to all repositories in the tenancy and overrides any individual repository settings. You can also lock the policy to prevent any changes to it. Verified References: Using Retention Rules to Preserve Data

Explanation

The use case that is NOT a valid use case for leveraging the Oracle Cloud Infrastructure (OCI) Events service is "Capturing the OCI Monitoring service alarms and invoking autoscaling of compute instances." The OCI Events service is designed to provide event-driven architecture and enable automated responses to events occurring within the Oracle Cloud Infrastructure. It allows you to react to changes and activities happening within your OCI resources. The Events service can be used to trigger actions based on events like file uploads, resource changes, or task completions. However, capturing the OCI Monitoring service alarms and invoking autoscaling of compute instances is not a direct functionality provided by the OCI Events service. Autoscaling based on monitoring metrics is typically handled by the OCI Autoscaling service, which is specifically designed for that purpose. The OCI Monitoring service provides monitoring and alerting capabilities, while the Autoscaling service handles the dynamic scaling of compute instances based on predefined policies and thresholds.

Explanation

The correct answer is: "Resiliency is about recovering from failures without downtime or data loss." Service resiliency, in the context of cloud-native applications, is the ability of a service or system to recover from failures and continue functioning without downtime or data loss. It involves designing and implementing mechanisms to handle failures, such as network outages, hardware failures, or software errors, in a way that minimizes the impact on the overall system. The goal of resiliency is to ensure that the application or service can continue to operate and provide a certain level of functionality, even in the face of failures. This typically involves techniques such as redundancy, fault tolerance, and graceful degradation. By implementing resiliency measures, a cloud-native application can recover and adapt to failures, maintain availability, and preserve data integrity. The other statements are not accurate regarding service resiliency: Resiliency is not about not bringing a service to a functioning state after a failure. Instead, it is about recovering from failures and ensuring continued functionality. Resiliency is not about avoiding failures entirely. While it is desirable to prevent failures, resiliency focuses on the ability to handle and recover from failures when they do occur. Resiliency testing is not limited to a test environment. It is important to test and validate the resiliency measures in both test environments and production environments to ensure the application can effectively handle failures in real-world scenarios.

An action is a response that you define for the rule to perform when the filter finds a matching event1. The action type specifies the service that you want to invoke by delivering the event message1. The following action types are available in OCI Events rule definition1:

Streaming: Send to a stream from Oracle Streaming Service.

Notifications: Send to an Oracle Notification Service topic.

Functions: Send to an Oracle Functions Service endpoint. Email is not a valid action type for OCI Events rule definition. To send an email as an action, you need to use the Notifications service and subscribe to a topic with an email protocol2.

Explanation

Oracle Functions does not currently support PL/SQL as a language for writing function code. PL/SQL is a procedural language used in Oracle Database for developing stored procedures, triggers, and other database-related code. However, Oracle Functions supports several other popular programming languages such as Go, Node.js, Python, and Java, allowing developers to choose the language that best suits their application requirements and their familiarity with the language. While PL/SQL is powerful for working with the Oracle Database, it is not an option for writing function code in the Oracle Functions serverless architecture.

Explanation

The correct answer in this scenario is to use the OCI API Gateway service and configure rate limiting. Using the OCI API Gateway service and configuring rate limiting is an effective approach to address Distributed Denial-of-Service (DDoS) attacks. By implementing rate limiting, you can control the number of requests that can be made to your web service within a specific time frame. This helps to prevent overload and ensures that your service can handle legitimate traffic while mitigating the impact of DDoS attacks. By leveraging the OCI API Gateway service, you can easily configure rate limiting rules to restrict the number of requests per second or per minute. This allows you to set appropriate thresholds and safeguard your web service from being overwhelmed by excessive requests. The API Gateway acts as a protective layer, filtering out malicious traffic and ensuring the smooth operation of your service. While options like OCI Virtual Cloud Network (VCN) segregation and third-party service integrations may contribute to overall security, they do not specifically address DDoS attacks as efficiently as rate limiting. VCN segregation focuses more on network segmentation and isolation, while third-party service integration may introduce additional dependencies and complexities. Re-writing your web service and implementing rate limiting is a viable option, but it may not be feasible considering the time constraints mentioned. Leveraging the OCI API Gateway service provides a quicker and easier solution to implement DDoS attack mitigation through rate limiting.