[Q38-Q60] 1Z0-1084-21 Practice Test Give You First Time Success with 100% Money Back Guarantee!

September 5, 2022 1Z0-1084-21, Oracle 0 Comments

[Q38-Q60] 1Z0-1084-21 Practice Test Give You First Time Success with 100% Money Back Guarantee!

Rate this post

1Z0-1084-21 Practice Test Give You First Time Success with 100% Money Back Guarantee!

All Obstacles During 1Z0-1084-21 Exam Preparation with 1Z0-1084-21 Real Test Questions

Oracle 1Z0-1084-21 Exam Syllabus Topics:

Topic	Details
Topic 1	Develop Serverless Application with Oracle Functions Develop Microservices and Applications for OKE
Topic 2	Overcome Security challenges with Cloud Native Discuss the Meaning of Serverless Computing
Topic 3	Explain Microservices vs. Containers vs. Functions Use OCI APIs, SDKs and CLIupgrade
Topic 4	Developing Cloud Native Applications Manage multiple environments (dev, test stage, prod)
Topic 5	Configure and Use Secret Management Operating Cloud Native Applications Cloud Native Fundamentals
Topic 6	Build, Deploy and Release Applications Testing Cloud Native Applications
Topic 7	Perform Tasks around Monitoring, Observability, and Alerting Explain Distributed Computing
Topic 8	Securing Cloud Native Applications Use the Defense-in-depth approach

Q38. A developer using Oracle Cloud Infrastructure (OCI) API Gateway must authenticate the API requests to their web application. The authentication process must be implementedusing a custom scheme which accepts string parameters from the API caller. Which method can the developer use In this scenario?

Create an authorizer function using request header authorization.

Create an authorizer function using token-based authorization.

Create a cross account functions authorizer.

Create an authorizer function using OCI Identity and Access Management based authentication

Explanation
Using Authorizer Functions to Add Authentication and Authorization to API Deployments:
You can control access to APIs you deploy to API gateways using an ‘authorizer function’ (as described in this topic), or using JWTs (as described in Using JSON Web Tokens (JWTs) to Add Authentication and Authorization to API Deployments).
You can add authentication and authorization functionality to API gateways by writing an ‘authorizer function’ that:
1. Processes request attributes to verify the identity of a caller with an identity provider.
2.Determines the operations that the caller is allowed to perform.
3.Returns the operations the caller is allowed to perform asa list of ‘access scopes’ (an ‘access scope’ is an arbitrary string used to determine access).
Optionally returns a key-value pair for use by the API deployment. For example, as a context variable for use in an HTTP back end definition (see Adding Context Variables to Policies and HTTP Back End Definitions).
Create an authorizerfunction using request header authorization implemented using a custom scheme which accepts string parameters from the API caller.
Managing Input Parameters
In our case we will need to manage quite a few static parameters in our code. For example the URLs of the secrets service endpoints, the username and other constant parameterised data. We can manage these either at Application or Function level (an OCI Function is packaged in an Application which can contain multiple Functions). In this case I will create function level parameters. You can use the following command to create the parameters:
fn config function test idcs-assert idcsClientId aedc15531bc8xxxxxxxxxxbd8a193

References:
https://technology.amis.nl/2020/01/03/oracle-cloud-api-gateway-using-an-authorizer-function-for-client-secret-a
https://docs.cloud.oracle.com/en-us/iaas/Content/APIGateway/Tasks/apigatewayusingauthorizerfunction.htm
https://www.ateam-oracle.com/how-to-implement-an-oci-api-gateway-authorization-fn-in-nodejs-that-accesses-o

Q39. You are deploying an API via Oracle Cloud Infrastructure (OCI) API Gateway and you want to implement request policies to control access Which is NOT available in OCI API Gateway?

Limiting the number of requests sent to backend services

Enabling CORS (Cross-Origin Resource Sharing) support

Providing authentication and authorization

Controlling access to OCI resources

Q40. Which two are characteristics of microservices?

Microservices are hard to test in isolation.

Microservicescan be independently deployed.

All microservices share a data store.

Microservices can be implemented in limited number of programming languages.

Microservices communicate over lightweight APIs.

Q41. You are developing a distributed application and you need a call to a path to always return a specific JSON content deploy an Oracle Cloud Infrastructure API Gateway with the below API deployment specification.

What is the correct value for type?

STOCK_RESPONSE_BACKEND

CONSTANT_BACKEND

JSON_BACKEND

HTTP_BACKEND

Q42. In order to effectively test your cloud-native applications, you might utilize separate environments (development, testing, staging, production, etc.). Which Oracle Cloud Infrastructure (OC1) service can you use to create and manage your infrastructure?

OCI Compute

OCI Container Engine for Kubernetes

OCI Resource Manager

OCI API Gateway

Q43. Who is responsiblefor patching, upgrading and maintaining the worker nodes in Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE)?

It Is automated

Independent Software Vendors

Oracle Support

The user

Explanation
After a new version of Kubernetes has been released and when Container Engine for Kubernetes supports the new version, you can use Container Engine for Kubernetes to upgrade master nodes running older versions of Kubernetes. Because Container Engine for Kubernetes distributes the KubernetesControl Plane on multiple Oracle-managed master nodes (distributed across different availability domains in a region where supported) to ensure high availability, you’re able to upgrade the Kubernetes version running on master nodes with zero downtime.
Having upgraded master nodes to a new version of Kubernetes, you can subsequently create new node pools running the newer version. Alternatively, you can continue to create new node pools that will run older versions of Kubernetes (providing those older versions are compatible with the Kubernetes version running on the master nodes).
Note that you upgrade master nodes by performing an ‘in-place’ upgrade, but you upgrade worker nodes by performing an ‘out-of-place’ upgrade. To upgrade the version of Kubernetesrunning on worker nodes in a node pool, you replace the original node pool with a new node pool that has new worker nodes running the appropriate Kubernetes version. Having ‘drained’ existing worker nodes in the original node pool to prevent new pods starting and to delete existing pods, you can then delete the original node pool.
Upgrading the Kubernetes Version on Worker Nodes in a Cluster:
After a new version of Kubernetes has been released and when Container Engine for Kubernetes supports the new version, you can use Container Engine for Kubernetes to upgrade master nodes running older versions of Kubernetes. Because Container Engine for Kubernetes distributes the Kubernetes Control Plane on multiple Oracle-managed master nodes (distributed across different availability domains in a region where supported) to ensure high availability, you’re able to upgrade the Kubernetes version running on master nodes with zero downtime.
You can upgrade the version of Kubernetes running on the worker nodes in a clusterin two ways:
(A) Perform an ‘in-place’ upgrade of a node pool in the cluster, by specifying a more recent Kubernetes version for new worker nodes starting in the existing node pool. First, you modify the existing node pool’s properties to specify the morerecent Kubernetes version. Then, you ‘drain’ existing worker nodes in the node pool to prevent new pods starting, and to delete existing pods. Finally, you terminate each of the worker nodes in turn.
When new worker nodes are started in the existing node pool, they run the more recent Kubernetes version you specified. See Performing an In-Place Worker Node Upgrade by Updating anExisting Node Pool.
(B) Perform an ‘out-of-place’ upgrade of a node pool in the cluster, by replacing the original node pool with a new node pool. First, you create a new node pool with a more recent Kubernetes version. Then, you ‘drain’ existing worker nodes in the original node pool to prevent new pods starting, and to delete existing pods.
Finally, you delete the original node pool. When new worker nodes are started in the new node pool, they run the more recent Kubernetes version you specified. See Performing an Out-of-Place Worker Node Upgrade by Replacing an Existing Node Pool with a New Node Pool.
Note that in both cases:
The more recent Kubernetes version you specify for the worker nodes in the node pool must be compatible with the Kubernetes version running on the master nodes in the cluster. See Upgrading Clusters to Newer Kubernetes Versions).
You must drain existing worker nodes in the original node pool. If you don’t drain the worker nodes, workloads running onthe cluster are subject to disruption.
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/ContEng/Tasks/contengupgradingk8sworkernode.htm

Q44. Which Oracle Cloud Infrastructure (OCI) load balancer shape is used by default in OCI container Engineer for Kubernetes?

400 Mbps

8000 Mbps

There is no default. The shape has to be specified.

100 Mbps

Q45. What is the open source engine for Oracle Functions?

Apache OpenWhisk

OpenFaaS

Fn Project

Knative

Q46. Which one of the following is NOT a valid backend-type supported by Oracle Cloud Infrastructure (OCI) API Gateway?

STOCK_RESPONSE_BACKEND

ORACLE_FUNCTIONS_BACKEND

ORACLE_STREAMS_BACKEND

HTTP_BACKEND

Q47. As a cloud-native developer, you have written a web service for your company. You have used Oracle Cloud Infrastructure (OCI) API Gateway service to expose the HTTP backend. However, your security team has suggested that your web service should handle Distributed Denial-of-Service (DDoS) attack. You are time-constrained and you need to make sure that this is implemented as soon as possible.
What should you do in this scenario?

Use OCI virtual cloud network (VCN) segregation to control DDoS.

Use a third party service integration to implement a DDoS attack mitigation,

Use OCI API Gateway service and configure rate limiting.

Re-write your web service and implement rate limiting.

Q48. Which concepthe following steps reference Console instructionsCloud Infrastructure Resource Manager?

Job

Stack

Queue

Plan

Q49. You are building a container image and pushing it to the Oracle Cloud Infrastructure Registry (OCIR). You need to make sure that these get deleted from the repository.
Which action should you take?

Create a group and assign a policy to perform lifecycle operations on images.

Set global policy of image retention to “Retain All Images”.

In your compartment, write a policy to limit accessto the specific repository.

Edit the tenancy global retention policy.

Q50. You have created a repository in Oracle Cloud Infrastructure Registry in the us-ashburn-1 (iad) region in your tenancy with a namespace called “heyci.
Which three are valid tags for an image named “myapp”?

iad.ocir.io/heyoci/myproject/myapp:0.0.1

us-ashburn-l.ocirJo/heyoci/myapp:0.0.2-beta

us-ashburn-l.ocir.io/heyoci/myproject/myapp:0.0.2-beta

us-ashburn-l.ocir.io/myproject/heyoci/myapp:latest

iad.ocir.io/myproject/heyoci/myapprlatest

iad.ocir.io/heyoci/myapp:0.0.2-beta

iad.ocir.io/heyoci/myapp:latest

Explanation
Give a tag to the image that you’re going to push to Oracle Cloud Infrastructure Registry by entering:
docker tag <image-identifier> <target-tag>
where:
<image-identifier> uniquely identifies the image, either using the image’s id (for example, 8e0506e14874), or the image’s name and tag separated by a colon (for example, acme-web-app:latest).
<target-tag> is in the
format <region-key>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag> where:
<region-key> is the key for the Oracle Cloud Infrastructure Registry region you’re using. For example, iad.
See Availability by Region.
ocir.io is the Oracle Cloud Infrastructure Registry name.
<tenancy-namespace> is the auto-generated Object Storage namespace string of the tenancy that owns the repository to which you want to push the image (as shown on the Tenancy Information page). For example, the namespace of the acme-dev tenancy might be ansh81vru1zp. Note that for some older tenancies, the namespace string might be the same as the tenancy name in all lower-case letters (for example, acme-dev).
Note also that your user must have access to the tenancy.
<repo-name> (if specified) is the name of a repository to which you want to push the image (for example, project01). Note that specifying a repository is optional (see About Repositories).
<image-name> is the name you want to give the image in Oracle Cloud Infrastructure Registry (for example, acme-web-app).
<tag> is an image tag you want to give the image in Oracle Cloud Infrastructure Registry (for example, version2.0.test).
For example, for convenience you might want to group together multiple versions of the acme-web-app image in the acme-dev tenancy in the Ashburn region into a repository called project01. You do this by including the name of the repository in the image name when you push the image, in the format <region-key>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>. For example, iad.ocir.io/ansh81vru1zp/project01/acme-web-app:4.6.3. Subsequently, when you use the docker push command, the presence of the repository in the image’s name ensures the image is pushed to the intended repository.
If you push an image and include the nameof a repository that doesn’t already exist, a new private repository is created automatically. For example, if you enter a command like docker push iad.ocir.io/ansh81vru1zp/project02/acme-web-app:7.5.2 and the project02 repository doesn’t exist, a privaterepository called project02 is created automatically.
If you push an image and don’t include a repository name, the image’s name is used as the name of the repository. For example, if you enter a command like docker pushiad.ocir.io/ansh81vru1zp/acme-web-app:7.5.2 that doesn’t contain a repository name, the image’s name (acme-web-app) is used as the name of a private repository.
https://docs.cloud.oracle.com/en-us/iaas/Content/Registry/Concepts/registrywhatisarepository.htm

Q51. A programmerIs developing a Node is application which will run in a Linux server on their on-premises data center. This application will access various Oracle Cloud Infrastructure (OC1) services using OCI SDKs.
What is the secure way to access OCI services with OCI Identity and Access Management (JAM)?

Create a new OCI IAM user associated with a dynamic group and a policy that grants the desired permissions to OCI services. Add the on-premises Linux server in the dynamic group.

Create an OCI IAM policy with theappropriate permissions to access the required OCI services and assign the policy to the on-premises Linux server.

Create a new OCI IAM user, add the user to a group associated with a policy that grants the desired permissions to OCI services. In the on-premises Linux server, generate the keypair used for signing API requests and upload the public key to the IAM user.

Create a new OCI IAM user, add the user to a group associated with a policy that grants the desired permissions to OCI services. In theon-premises Linux server, add the user name and password to a file used by Node.js authentication.

Q52. Which two are benefits of distributed systems?

Privacy

Security

Ease of testing

Scalability

Resiliency

Explanation
distributed systems of native-cloud like functions that have a lot of benefit like Resiliency and availability Resiliency andavailability refers to the ability of a system to continue operating, despite the failure or sub-optimal performance of some of its components.
In the case of Oracle Functions:
The control plane is a set of components that manages function definitions.
Thedata plane is a set of components that executes functions in response to invocation requests.
For resiliency and high availability, both the control plane and data plane components are distributed across different availability domains and fault domains ina region. If one of the domains ceases to be available, the components in the remaining domains take over to ensure that function definition management and execution are not disrupted.
When functions are invoked, they run in the subnets specified for theapplication to which the functions belong.
For resiliency and high availability, best practice is to specify a regional subnet for an application (or alternatively, multiple AD-specific subnets in different availability domains). If an availability domainspecified for an application ceases to be available, Oracle Functions runs functions in an alternative availability domain.
Concurrency and Scalability
Concurrency refers to the ability of a system to run multiple operations in parallel using shared resources.
Scalability refers to the ability of the system to scale capacity (both up and down) to meet demand.
In the case of Functions, when a function is invoked for the first time, the function’s image is run as a container on an instance in a subnetassociated with the application to which the function belongs. When the function is executing inside the container, the function can read from and write to other shared resources and services running in the same subnet (for example, Database as a Service).The function can also read from and write to other shared resources (for example, Object Storage), and other Oracle Cloud Services.
If Oracle Functions receives multiple calls to a function that is currently executing inside a running container, Oracle Functions automatically and seamlessly scales horizontally to serve all the incoming requests. Oracle Functions starts multiple Docker containers, up to the limit specified for your tenancy. The default limit is 30 GB of RAM reserved for function execution per availability domain, although you can request an increase to this limit. Provided the limit is not exceeded, there is no difference in response time (latency) between functions executing on the different containers.

Q53. Which is NOT a supported SDK on Oracle Cloud Infrastructure (OCI)?

Ruby SDK

Java SDK

Python SDK

Go SDK

.NET SDK

Q54. You have deployed a Python application on Oracle Cloud Infrastructure Container Engine for Kubernetes.
However, during testing you found a bug that you rectified and created a new Docker image. You need to make sure that if this new Image doesn’t work then you can roll back to the previous version.
Using kubectl, which deployment strategies should you choose?

Rolling Update

Canary Deployment

Blue/Green Deployment

A/B Testing

Q55. A leading insurancefirm is hosting its customer portal in Oracle Cloud Infrastructure (OCI) Container Engine for Kubernetes with an OCI Autonomous Database. Their support team discovered a lot of SQL injection attempts and cross-site scripting attacks to the portal, which isstarting to affect the production environment.
What should they implement to mitigate this attack?

Network Security Lists

Network Security Groups

Network Security Firewall

Web Application Firewall

Q56. Which two statements are true for serverless computing and serverless architectures?

Long running tasks are perfectly suited for serverless

Serverless function state should never be stored externally

Application DevOps team is responsible for scaling

Serverless function execution is fully managed by a third party

Applications running on a FaaS (Functions as a Service) platform

Q57. You have written a Node.js function and deployed it to Oracle Functions. Next, you need to call this function from a microservicewritten in Java deployed on Oracle Cloud Infrastructure (OCI) Container Engine for Kubernetes (OKE).
Which can help you to achieve this?

Use the OCI CLI with kubect1 to invoke the function from the microservice.

Oracle Functions does not allow a microservice deployed on OKE to invoke a function.

OKE does not allow a microservice to invoke a function from Oracle Functions.

Use the OCI Java SDK to invoke the function from the microservice.

Q58. You are building a cloud native, serverless travel application with multiple Oracle Functions in Java, Python and Node.js. You need to build and deploy these functions to a single applications named travel-app.
Which command will help you complete this task successfully?

oci fn function deploy –ap travel-ap –all

fn -v deploy –ap travel-ap — all

oci fn application –application-name-ap deploy –all

fn function deploy –all –application-name travel-ap

Q59. In a Linux environment, what is the default locations of the configuration file that Oracle Cloud Infrashtructure CLI uses for profile information/

/etc/.oci/config

/usr/local/bin/config

SHOME/.oci/config

/usr/bin/oci/config

Q60. Which pattern can help you minimize the probability of cascading failures in your system during partial loss of connectivity or a complete service failure?

Retry pattern

Anti-corruption layer pattern

Circuit breaker pattern

Compensating transaction pattern