1z0-1084-25 Oracle Cloud Infrastructure 2025 Developer Professional Questions and Answers

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.

To push a new Docker container image to a repository in OCI Registry, you need to use an Auth Token to complete the authentication via the Docker CLI1. An Auth Token is a secure, auto-generated password that you can use to authenticate with OCI services such as OCI Registry1. You can generate an Auth Token in the Console by following these steps1:

In the top-right corner of the Console, open the Profile menu and then click User settings to view the details.

On the Auth Tokens page, click Generate Token.

Enter a friendly description for the auth token. Avoid entering confidential information.

Click Generate Token. The new auth token is displayed.

Copy the auth token immediately to a secure location from where you can retrieve it later, because you won’t see the auth token again in the Console.

Close the Generate Token dialog. After generating an Auth Token, you need to log in to OCI Registry by entering docker login .ocir.io in a terminal window on the client machine running Docker, where corresponds to the key for the OCI Registry region you’re using1. When prompted for a username, enter your username in the format /, where is the auto-generated Object Storage namespace string of your tenancy1. When prompted for a password, enter the Auth Token you copied earlier1.

Explanation

The correct answer is: Controlling access to the backend OCI resources. OCI API Gateway does not provide direct control over access to backend OCI resources. It primarily focuses on managing and securing access to APIs exposed through the gateway. The gateway acts as a front-end for APIs and provides features such as authentication, authorization, rate limiting, and CORS support. While you can configure authentication and authorization policies, limit the number of requests, and enable CORS support in OCI API Gateway, it does not directly control access to backend OCI resources. Access to backend resources is typically managed through other means, such as IAM policies, network security rules, or resource-specific access controls.

Explanation

(OPT) iad.ocir.io/myproject/heyoci/myapp:latest The three valid tags for an image named myapp in the heyoci namespace of the Oracle Cloud Infrastructure Registry (OCIR) in the us-ashburn-1 (iad) region are: iad.ccir.io/heyoci/myapp:latest This tag specifies the latest version of the myapp image in the heyoci namespace in the iad region. iad.ocir.io/heyoci/myapp:0.0.2-beta This tag specifies version 0.0.2-beta of the myapp image in the heyoci namespace in the iad region. us-ashburn-1.ocir.io/heyoci/myapp:0.0.2-beta This tag specifies version 0.0.2-beta of the myapp image in the heyoci namespace in the us-ashburn-1 region. The other options mentioned are not valid tags for the given scenario: us-ashburn-1.ocir.io/heyoci/myapp:0.0.2-beta (incorrect format, missing the namespace) iad.ocir.io/myproject/heyoci/myapp:latest (incorrect format, incorrect order of namespace and project) us-ashburn-1.ocir.io/myproject/heyoci/myapp:latest (incorrect format, incorrect order of namespace and project) The correct format for tagging an image in OCIR is .ocir.io//:.

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

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 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.

Blue/Green deployment strategy allows releasing a new version of an application using two identical environments where one of them is active at a given time. The current version of the application is provisioned on the active environment, whereas the new version gets deployed to the standby environment1. The traffic is shifted from the active to the standby environment by updating the ingress resource2. Therefore, both old and new application versions are deployed to production at the same time, but only one of them receives the traffic. Verified References: Announcing new deployment strategies for OCI DevOps Service, Blue-Green OKE Deployment

Explanation

The two statements that are NOT valid regarding the Oracle Cloud Infrastructure (OCI) Streaming service are: A stream can be configured with either a public or a private endpoint with support for customer managed encryption keys. This statement is not valid because the OCI Streaming service currently supports only private endpoints. Customer managed encryption keys are not currently supported for OCI Streaming. OCI Streaming can support up to 2,000 requests per second to each partition. This statement is not valid because the throughput of a stream is not defined by the partition in terms of requests per second. The throughput of a stream is defined in terms of data input and output rates. Each partition provides 1 MB/sec data input and 2 MB/sec data output, but it does not correspond to a specific number of requests per second. The other statements are valid: OCI Streaming stores all data for 24 hours by default, but that can be extended up to 7 days. Although OCI Streaming automatically encrypts all data while in transit, it is the developer's responsibility to encrypt data at rest, if needed.

Explanation

The correct answer is: "Tightly coupled." Tightly coupling is not a criterion that is usually met by a microservice. In fact, microservices are designed to be loosely coupled. Loosely coupling refers to reducing dependencies and minimizing the direct interactions between different components or services. Microservices promote independence and autonomy, allowing each service to operate independently without being tightly bound to other services. The other options listed are criteria that are typically met by microservices: Organized around business capabilities: Microservices architecture suggests designing services around specific business capabilities or functionalities. This allows for focused and specialized services that align with the organization's business needs. Independently deployable: Microservices are designed to be independently deployable units. Each microservice can be developed, tested, and deployed separately, without impacting other services. This enables agility and scalability in the deployment process. Highly maintainable: Microservices are often designed to be highly maintainable. They are smaller in scope and focused on specific tasks, making it easier to manage and maintain individual services. Additionally, microservices can be updated, patched, or replaced without affecting the entire system, facilitating easier maintenance and evolution of the application. Therefore, the criterion that is NOT typically met by a microservice is being tightly coupled.

Explanation

The valid OKE cluster network configuration that meets the requirement of having the least attack surface while still allowing direct access to the deployed applications from the Internet is: Private subnets for nodes and the Kubernetes API endpoint; public subnets for load balancers. By placing the nodes and the Kubernetes API endpoint in private subnets, they are not directly accessible from the Internet, reducing the attack surface. The load balancers, on the other hand, are placed in public subnets, allowing them to be accessed from the Internet and serve as the entry point for accessing the deployed applications. This configuration ensures that the critical components of the cluster, such as the nodes and the API endpoint, are protected within the private network, while still providing accessibility to the applications through the load balancers. It helps to enhance security by limiting direct access to the internal components of the cluster while maintaining the availability of the deployed applications.

Explanation

The correct statements are: A common context to store configuration variables that are available to all functions in the application. A Docker image containing all the functions that share the same configuration. A logical group of functions. Explanation: An Oracle Functions application provides a common context for functions within the application. It allows you to store configuration variables that are accessible by all the functions in the application. Functions within the same application can share the same Docker image, which contains the common configuration and dependencies. An Oracle Functions application serves as a logical group that organizes related functions. Functions within the same application can be managed collectively, and they can interact and share resources within the application context.

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 feature that is typically NOT associated with Cloud Native is "Application Servers." Cloud Native architecture emphasizes lightweight, scalable, and containerized deployments, which often replace traditional monolithic application servers. Instead of relying on application servers, Cloud Native applications are typically deployed as containerized microservices that can be orchestrated and managed using container orchestration platforms like Kubernetes. This approach enables greater flexibility, scalability, and agility in deploying and managing applications. While application servers have been widely used in traditional application architectures, they are not a characteristic feature of Cloud Native architectures. Cloud Native architectures focus on containerization, declarative APIs, immutable infrastructure, and service meshes to enable efficient and scalable deployment and management of applications.

Explanation

The correct answer is: Test using an API mock of service B. To test service A without deploying all of its dependencies, including service B, you can use an API mock of service B. An API mock is a simulated version of the API that mimics the behavior of the actual service. By using an API mock, you can isolate the testing of service A and simulate the responses and behavior of service B's APIs. With an API mock, you can define the expected responses and behavior of service B's APIs, allowing you to test the integration between service A and the mocked version of service B. This approach enables you to verify the functionality of service A without relying on the availability or changes in the actual service B. By decoupling the dependencies and using an API mock, you can perform independent testing of service A, ensuring its functionality in isolation.

Explanation

The correct answer is: "Create a self-signed certificate and its corresponding key. Create a Kubernetes secret using the certificate and the key. Then add these annotations to the Kubernetes service: annotations: service.beta.kubernetes.io/oci-load-balancer-ssl-ports: '443' service.beta.kubernetes.io/oci-load-balancer-tls-secret: ssl certificate-secret." To create a secure SSL termination for your microservices-based application running in an OCI Container Engine for Kubernetes (OKE) cluster, you can follow these steps: Create a self-signed certificate and its corresponding key: Generate a self-signed SSL certificate and its private key using a tool like OpenSSL. Create a Kubernetes secret: Create a Kubernetes secret using the certificate and key obtained in the previous step. This secret will securely store the certificate and key within the Kubernetes cluster. Add annotations to the Kubernetes service: Modify the Kubernetes service that exposes your application and add the following annotations to enable SSL termination: annotations: service.beta.kubernetes.io/oci-load-balancer-ssl-ports: '443' (specify the SSL port as 443) annotations: service.beta.kubernetes.io/oci-load-balancer-tls-secret: ssl certificate-secret (specify the name of the Kubernetes secret containing the certificate and key) By following these steps, you can create a secure SSL termination for your application using a self-signed certificate and Kubernetes secret. The annotations added to the Kubernetes service ensure that the SSL port is configured correctly and the TLS secret is utilized for SSL termination when traffic reaches the load balancer. The other options provided are not the most suitable approaches for achieving secure SSL termination in an OCI Container Engine for Kubernetes (OKE) cluster: Adding annotations related to the OCI load balancer SSL secret key is not the correct approach for SSL termination in this scenario. Using Let's Encrypt to generate a self-signed certificate and configuring it on the OCI Load Balancer is not necessary when you can create and manage the SSL certificate within the Kubernetes cluster using a Kubernetes secret.

Explanation

The two main reasons to choose a serverless architecture are: Automatic horizontal scaling: Serverless architectures allow for automatic scaling of resources based on demand. The infrastructure automatically provisions and scales resources as needed, ensuring that applications can handle varying workloads efficiently. This eliminates the need for manual scaling and optimizes resource utilization. Reduced operational cost: Serverless architectures follow a pay-per-use model, where you are billed only for the actual execution time and resources consumed by your functions. This leads to cost savings as you don't have to pay for idle resources. Additionally, serverless architectures remove the need for managing and maintaining servers, reducing operational overhead and associated costs. Explanation: No need for integration testing: Integration testing is still necessary in serverless architectures to ensure that functions integrate correctly with other components and services. Serverless functions can interact with various event sources, databases, and APIs, and testing is required to verify the integration points. Improved in-function state management: Serverless architectures typically encourage stateless functions that operate on short-lived requests or events. While there are mechanisms to manage state within a function, serverless architectures are designed to be stateless by default, promoting scalability and fault tolerance. Easier to run long-running operations: Serverless functions are generally designed for short-lived operations rather than long-running tasks. If you have a requirement for long-running operations, a serverless architecture may not be the ideal choice, as it has execution time limits and may not provide the necessary resources for extended execution.

Explanation

The two correct differences between continuous delivery and continuous deployment in the DevOps lifecycle are: Continuous delivery is a process that initiates deployment manually, while continuous deployment is based on automating the deployment process. In continuous delivery, the software is ready for deployment, but the decision to deploy is made manually by a human. On the other hand, continuous deployment automates the deployment process, and once the software passes all the necessary tests and quality checks, it is automatically deployed without human intervention. Continuous delivery involves automatic deployment to a development environment, while continuous deployment involves automatic deployment to a production environment. In continuous delivery, the software is automatically deployed to a development or staging environment for further testing and validation. However, the actual deployment to the production environment is performed manually. In continuous deployment, the software is automatically deployed to the production environment, eliminating the need for manual intervention in the deployment process. These differences highlight the level of automation and human involvement in the deployment process between continuous delivery and continuous deployment approaches in the DevOps lifecycle.

Explanation

The option that is NOT valid about troubleshooting Oracle Functions is: "Oracle Functions tracing is enabled at the function level." In Oracle Functions, tracing is not enabled at the function level. Instead, tracing is enabled at the application level. When you enable tracing for an application, it applies to all the functions within that application. Tracing allows you to capture detailed information about the execution flow and performance of the functions, helping you analyze and debug issues. The other options mentioned are valid: Oracle Functions invocation logs are enabled at the application level. Invocation logs provide visibility into the details of function invocations, including input, output, duration, and any error messages. These logs are generated and stored by Oracle Functions, and you can access them for troubleshooting and monitoring purposes. Oracle Functions invocation is enabled by default. Once you deploy a function, it becomes invocable by default. You can configure different triggers to invoke the function, such as HTTP requests, scheduled events, or events from other Oracle Cloud Infrastructure services. Oracle Functions metrics are available at both the function and application level. Metrics provide insights into the usage, performance, and behavior of functions. They can include metrics such as invocations per minute, average duration, and error counts. These metrics can be viewed in the Oracle Cloud Infrastructure Console or accessed programmatically through APIs. It's important to note that the specific configuration and behavior of monitoring, logging, and tracing in Oracle Functions may depend on the version, configuration, and options you have chosen. It is recommended to refer to the Oracle Functions documentation and consult the official documentation for accurate and up-to-date information on troubleshooting and monitoring Oracle Functions.

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 step that is NOT required for setting up the Container Engine for Kubernetes (OKE) cluster access using a local installation of kubectl is to generate an Auth token from the OCI console. The authentication for accessing the OKE cluster using kubectl can be performed using the OCI CLI configuration, specifically the API signing key pair and the kubeconfig file. Here are the correct steps for setting up the OKE cluster access using a local installation of kubectl: Set up the kubeconfig file: The kubeconfig file contains the necessary information to authenticate and access the OKE cluster using kubectl. It includes details such as the cluster endpoint, authentication method, and credentials. Generate an API signing key pair (if you do not already have one) and upload the public key of the API signing key pair: The API signing key pair is used for authentication with the OCI services. The public key of the key pair needs to be uploaded to the OCI Console to associate it with your user account. Install and configure the Oracle Cloud Infrastructure (OCI) CLI: The OCI CLI provides a command-line interface to interact with the OCI services. It needs to be installed and configured with your OCI credentials, including the user's OCID, tenancy OCID, region, and the path to the API signing key pair. By completing these steps, you can configure kubectl to access and manage your OKE clusters from your local machine using the OCI CLI authentication configuration.

OCI Queue is a fully managed serverless service that helps decouple systems and enable asynchronous operations2. Queue handles high-volume transactional data that requires independently processed messages without loss or duplication2. A valid use case for OCI Queue is building decoupled and scalable systems, such as event-driven architectures or microservices-based applications2. For example, you can use Queue to decouple your application and build an event-driven architecture. Decoupling ensures that individual application components can scale independently and that you can future-proof your design so that as new application components are built, they can publish or subscribe to the queue2.

Explanation

The maximum execution time of Oracle Functions is 300 seconds, which is equivalent to 5 minutes. This means that a function running within Oracle Functions cannot exceed a runtime of 5 minutes. If a function requires longer execution times, alternative approaches such as invoking external services asynchronously or using long-running processes should be considered. It is important to design functions with this execution time limitation in mind to ensure optimal performance and efficiency within the Oracle Functions platform.

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.

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

To dynamically make Kubernetes resources discoverable to public DNS servers, you can use ExternalDNS. ExternalDNS is a Kubernetes add-on that automates the management of DNS records for your Kubernetes services and ingresses. It can be configured to monitor the changes in your Kubernetes resources and automatically update DNS records in a supported DNS provider. By integrating ExternalDNS with your Kubernetes cluster, you can ensure that the DNS records for your services and ingresses are automatically created, updated, or deleted based on changes in your Kubernetes resources. This allows your Kubernetes resources to be discoverable by external systems through public DNS servers.

API mocking is a technique that simulates the behavior of real APIs without requiring the actual implementation or deployment of the dependent services1. API mocking allows you to test changes to service A without deploying all of its dependencies, such as service B, by creating mock responses for the APIs that service A relies on1. API mocking has several benefits, such as1:

Faster testing: You can test your service A without waiting for service B to be ready or available, which reduces the testing time and feedback loop.

Isolated testing: You can test your service A in isolation from service B, which eliminates the possibility of external factors affecting the test results or causing errors.

Controlled testing: You can test your service A with different scenarios and edge cases by creating mock responses that mimic various situations, such as success, failure, timeout, etc.