Oracle 1z0-1084-22 Oracle Cloud Infrastructure 2022 Developer Professional Exam Practice Test

Resource Manager is an OracleCloud Infrastructure service that allows you to automate the process of provisioning your Oracle Cloud Infrastructure resources. Using Terraform, Resource Manager helps you install, configure, and manage resources through the "infrastructure-as-code" model.

References:

https://docs.cloud.oracle.com/iaas/Content/ResourceManager/Concepts/resourcemanager.htm

Application and systems logs can help you understand what ishappening inside your cluster. The logs are particularly useful for debugging problems and monitoring cluster activity. Most modern applications have some kind of logging mechanism; as such, most container engines are likewise designed to support some kind of logging. The easiest and most embraced logging method for containerized applications is to write to the standard output and standard error streams.

Kubernetes also provides cluster-based logging to record container activity into a central logging subsystem. The standard output and standard error output of each container in a Kubernetes cluster can be ingested using an agent like Fluentd running on each node into tools like Elasticsearch and viewed with Kibana. And finally, monitor containers, pods, applications, services, and other components of your cluster. One can use tools such as Prometheus, Grafana, Jaeger for monitoring, visibility, and tracing the cluster.

References:

https://dzone.com/articles/5-best-security-practices-for-kubernetes-and-oracle-kubernetes-engine

https://kubernetes.io/docs/concepts/cluster-administration/logging/

https://blogs.oracle.com/developers/5-best-practices-for -kubernetes-security

distributed systems of native-cloud like functions that have a lot of benefit like

Resiliency and availability

Resiliency and availability refers to the ability of asystem 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.

The data plane is a set of components thatexecutes 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 in a region. If one of the domains ceasesto 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 the application 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 domain specified 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 subnet associated with the application to which thefunction 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 toother 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.

If you are running your Kubernetes cluster on Oracle Container Engine for Kubernetes (commonly known as OKE), you can have OCI automatically provision load balancers for you by creating a Service of type LoadBalancer instead of (or in addition to) installing an ingress controller like Traefik or Voyage

YAML file

When you apply this YAML file to your cluster, you will see the new service is created. After a short time (typically less than a minute) the OCI Load Balancer will be provisioned.

https://oracle.github.io/weblogic-kubernetes-operator /faq/oci-lb/

The shape of an Oracle Cloud Infrastructure load balancer specifies its maximum total bandwidth (that is, ingress plus egress). By default, load balancers are created with a shape of 100Mbps. Other shapes are available, including400Mbps and 8000Mbps.

To specify an alternative shape for a load balancer, add the following annotation in the metadata section of the manifest file:

service.beta.kubernetes.io/oci-load-balancer-shape:

where value is the bandwidth of the shape (for example, 100Mbps, 400Mbps, 8000Mbps).

For example:

apiVersion: v1

kind: Service

metadata:

name: my-nginx-svc

labels:

app: nginx

annotations:

service.beta.kubernetes.io/oci-load-balancer-shape: 400Mbps

spec:

type: LoadBalancer

ports:

-port: 80

selector:

app: nginx

https://github.com/oracle/oci-cloud-controller-manager/blob/master/docs/load-balancer-annotations.md

Overview ofEvents

Oracle Cloud Infrastructure Events enables you to create automation based on the state changes of resources throughout your tenancy. Use Events to allow your development teams to automatically respond when a resource changes its state.

Event Rules must also specify an action to trigger when the filter finds a matching event. Actions are responses you define for event matches. You set up select Oracle Cloud Infrastructure services that the Events service has established as actions. The resources forthese services act as destinations for matching events. When the filter in the rule finds a match, the Events service delivers the matching event to one or more of the destinations you identified in the rule. The destination service that receives the eventthen processes the event in whatever manner you defined. This delivery provides the automation in your environment.

You can only deliver events to certain Oracle Cloud Infrastructure services with a rule. Use the following services to create actions:

Notifications

Streaming

Functions

References:

https://docs.cloud.oracle.com/en-us/iaas /Content/Events/Concepts/eventsoverview.htm

microservice is larger and can do more than a function. A function is a relatively small bit of code that performs only one action in response to an event.

Many microservices can run on several servers, and different instances of a specific microservice can run on several servers.

In many cases, microservices can be decomposed into a number of smaller stateless functions. The difference between microservices and functions is not simply the size. Functions are stateless, and they require no knowledge about or configuration of the underlying server—hence, the term serverless.

Microservices are best suited for long-running, complex applications that have significant resource and management requirements. You can migrate an existing monolithic application to microservices, which makes it easier to modularly develop features for the application and deploy it in the cloud. Microservices are also a good choice for building e-commerce sites, as they can retain information throughout a transaction and meet the needs of a 24/7 customer base.

On the other hand, serverless functions only execute when needed. Once the execution is over, the computing instance that runs the code decommissions itself. Serverless aligns with applications that are event driven, especially when the events are sporadic and the event processingis not resource-intensive. Serverless is a good choice when developers need to deploy fast and there are minimal application scaling concerns. For example, a good use of serverless computing is a scheduled task that needs to perform some data aggregation and will execute for just a few seconds.

References:

https://www.cloudflare.com/learning/serverless/glossary/serverless-microservice/

https://developer.oracle.com/java/fn-project-introduction.html

https://searchapparchitecture.techtarget.com/answer/When-should-I-choose-between-serverless-and-microservices

Pulling Images from Registry during Deployment

During the deployment of an application to a Kubernetes cluster, you'll typically want one or more images to be pulled from a Docker registry. In the application's manifest file you specify the images to pull, the registry to pull them from, and the credentials to use when pulling the images. The manifest file is commonly also referred to as a pod spec, or as a deployment.yaml file (although other filenames are allowed).

If you want the application to pull images that reside in Oracle Cloud Infrastructure Registry, you have to perform two steps:

- You have to use kubectl to create a Docker registry secret. The secret containsthe Oracle Cloud Infrastructure credentials to use when pulling the image. When creating secrets, Oracle strongly recommends you use the latest version of kubectl

To create a Docker registry secret:

1- If you haven't already done so, follow the steps to set up the cluster's kubeconfig configuration file and (if necessary) set the KUBECONFIG environment variable to point to the file. Note that you must set up your own kubeconfig file. You cannot access a cluster using a kubeconfig file that a different userset up.

2- In a terminal window, enter:

$ kubectl create secret docker-registry --docker-server=.ocir.io --docker-username='/' --docker-password='' --docker-email=''

where:

 is a name of your choice, that you will use in the manifest file to refer to the secret . For example, ocirsecret

 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.

 is the auto-generated Object Storage namespace string of the tenancy containing the repository from which the application is to pull 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, thenamespace string might be the same as the tenancy name in all lower-case letters (for example, acme-dev).

 is the username to use when pulling the image. The username must have access to the tenancy specified by . For example, jdoe@acme.com . If your tenancy is federated with Oracle Identity Cloud Service, use the format oracleidentitycloudservice/

 is the auth token of the user specified by . For example, k]j64r{1sJSSF-;)K8

 is an email address. An email address is required, but it doesn't matter what you specify. For example, jdoe@acme.com

- You have to specify the image to pull from Oracle Cloud Infrastructure Registry, including the repository location and the Dockerregistry secret to use, in the application's manifest file.

References:

https://docs.cloud.oracle.com/en-us/iaas/Content/Registry/Tasks/registrypullingimagesfromocir.htm

Oracle SQL Developer WebOracle SQLDeveloper Web in Autonomous Data Warehouse provides a development environment and a data modeler interface for Autonomous Databases. SQL Developer Web is available for databases with both dedicated Exadata infrastructure and shared Exadata infrastructure.

https://docs.cloud.oracle.com/en-us/ iaas/Content/Database/Tasks/adbtools.htm

A cascading failure is a failure that grows over time as a result of positive feedback. It can occur when a portion of an overall system fails, increasing theprobability that other portions of the system fail.

the circuit breaker pattern prevents the service from performing an operation that is likely to fail. For example, a client service can use a circuit breaker to prevent further remote calls over the network when a downstream service is not functioning properly. This can also prevent the network from becoming congested by a sudden spike in failed retries by one service to another, and it can also prevent cascading failures. Self-healing circuit breakers check the downstream service at regular intervals and reset the circuit breaker when the downstream service starts functioning properly.

https://blogs.oracle.com/developers/getting-started-with-microservices-part-three