Explanation
https://docs.cloud.oracle.com/en-us/iaas/Content/ResourceManager/Concepts/resourcemanager.htm Following are brief descriptions of key concepts and the main components of Resource Manager.
CONFIGURATION
Information to codify your infrastructure. A Terraform configuration can be either a solution or a file that you write and upload.
JOB
Instructions to perform the actions defined in your configuration. Only one job at a time can run on a given stack; further, you can have only one set of Oracle Cloud Infrastructure resources on a given stack. To provision a different set of resources, you must create a separate stack and use a different configuration.
Resource Manager provides the following job types:
Plan: Parses your Terraform configuration and creates an execution plan for the associated stack. The execution plan lists the sequence of specific actions planned to provision your Oracle Cloud Infrastructure resources. The execution plan is handed off to the apply job, which then executes the instructions.
Apply. Applies the execution plan to theassociated stack to create (or modify) your Oracle Cloud Infrastructure resources. Depending on the number and type of resources specified, a given apply job can take some time. You can check status while the job runs.
Destroy. Releases resources associated with a stack. Released resources are not deleted. For example, terminates a Compute instance controlled by a stack. The stack’s job history and state remain after running a destroy job. You can monitor the status and review the results of a destroy job by inspecting the stack’s log files.
Import State. Sets the provided Terraform state file as the current state of the stack. Use this job to migrate local Terraform environments to Resource Manager.
STACK
The collection of Oracle Cloud Infrastructure resources corresponding to a given Terraform configuration.
Each stack resides in the compartment you specify, in a single region;however, resources on a given stack can be deployed across multiple regions. An OCID is assigned to each stack.
the following steps reference Console instructions
Create a Terraform configuration.
Create a stack.
Run a plan job, which produces an executionplan.
Review the execution plan.
If changes are needed in the execution plan, update the configuration and run a plan job again.
Run an apply job to provision resources.
Review state file and log files, as needed.
You can optionally reapply your configuration, with or without making changes, by running an apply job again.
Optionally, to release the resources running on a stack, run a destroy job.

Explanation
What Is Cloud Native?
Cloud native technologies arecharacterized by the use of containers, microservices, serverless functions, development pipelines, infrastructure expressed as code, event-driven applications, and Application Programming Interfaces (APIs). Cloud native enables faster software developmentand the ability to build applications that are resilient, manageable, observable, and dynamically scalable to global enterprise levels.
When constructing a cloud-native application, you’ll want to be sensitive to how back-end services communicate with each other. Ideally, the less inter-service communication, the better. However, avoidance isn’t always possible as back-end services often rely on one another to complete an operation.
While direct HTTP calls between microservices are relatively simple to implement, care should be taken to minimize this practice. To start, these calls are always synchronous and will block the operation until a result is returned or the request times outs. What were once self-contained, independent services, able to evolve independently and deploy frequently, now become coupled to each other. As coupling among microservices increase, their architectural benefits diminish.
Executing an infrequent request that makes a single direct HTTP call to another microservice might be acceptable for some systems. However, high-volume calls that invoke direct HTTP calls to multiple microservices aren’t advisable. They can increase latency and negatively impact the performance, scalability, and availability of your system. Even worse, a longseries of direct HTTP communication can lead to deep and complex chains of synchronous microservices calls, shown in Figure 4-9:

A message queue is an intermediary construct through which a producer and consumer pass a message.
Queues implement an asynchronous, point-to-point messaging pattern.
Events
Message queuing is an effective way to implement communication where a producer can asynchronously send a consumer a message.
References:
https://www.xenonstack.com/blog/cloud-native-architecture/
https://www.oracle.com/sa/cloud/cloud-native/
https://www.oracle.com/technetwork/topics/entarch/cloud-native-app-development-wp-3664668.pdf

Explanation
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

Explanation
Setting Up Local Access to Clusters
To set up a kubeconfig file to enable access to a cluster using a local installation of kubectl and theKubernetes Dashboard:
Step 1: Generate an API signing key pair
Step 2: Upload the public key of the API signing key pair
Step 3: Install and configure the Oracle Cloud Infrastructure CLI
Step 4: Set up the kubeconfig file
Step 5: Verify that kubectl can access the cluster
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/ContEng/Tasks/contengdownloadkubeconfigfile.htm

Explanation
Adding Request Policies and Response Policies to API Deployment Specifications:
You can control thebehavior of an API deployment you create on an API gateway by adding request and response policies to the API deployment specification:
a request policy describes actions to be performed on an incoming request from a caller before it is sent to a back end a response policy describes actions to be performed on a response returned from a back end before it is sent to a caller You can use request policies to:
limit the number of requests sent to back-end services
enable CORS (Cross-Origin Resource Sharing) support
provide authentication and authorization
You can add request and response policies that apply globally to all routes in an API deployment specification, and also (in some cases) request and response policies that apply only to particular routes.
Notethe following:
No response policies are currently available.
API Gateway request policies and response policies are different to IAM policies, which control access to Oracle Cloud Infrastructure resources.
You can add request and response policies to anAPI deployment specification by:
using the Console
editing a JSON file
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/APIGateway/Tasks/apigatewayaddingrequestpolicies.htm

Explanation
https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/sdks.htm

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

Explanation
You can invoke a function that you’ve deployed to Oracle Functions in different ways:
Using the Fn Project CLI.
Using the Oracle Cloud Infrastructure CLI.
Using the Oracle Cloud Infrastructure SDKs.
Making a signed HTTP request to the function’s invoke endpoint. Every function has an invoke endpoint.
Each of the above invokes the function via requests to the API. Any request to the API must be authenticated by including a signature and the OCID of the compartmentto which the function belongs in the request header.
Such a request is referred to as a ‘signed’ request. The signature includes Oracle Cloud Infrastructure credentials in an encrypted form.

Explanation
Adding OCI Service Broker for Kubernetes to Clusters:
Service brokers offer a catalog of backing services to workloads running on cloud native platforms. The Open Service Broker API is a commonly-used standard for interactions between service brokers and platforms. The Open Service Broker API specification describes a simple set of API endpoints that platforms use to provision, gain access to, and manage service offerings. Formore information about the Open Service Broker API, see resources available online including those at openservicebrokerapi.org.
OCI Service Broker for Kubernetes is an implementation of the OpenService Broker API. OCI Service Broker for Kubernetes is specifically for interacting with Oracle Cloud Infrastructure services from Kubernetes clusters. It includes three service broker adapters to bind to the following Oracle Cloud Infrastructure services:
-Object Storage
-Autonomous Transaction Processing
-Autonomous Data Warehouse
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/ContEng/Tasks/contengaddingservicebrokers.htm

Explanation
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

Explanation
https://docs.cloud.oracle.com/en-us/iaas/Content/Streaming/Concepts/streamingoverview.htm
Building consumers to read and process messages from a stream using the GetMessages API .
How StreamingWorks:
The Streaming service provides a robust, scalable mechanism that you can use to produce and consume high volumes of data between application components.
Here’s how Streaming works: a producer publishes messages to a stream, which is an append-only log. These messages are distributed among the partitions using the message’s key.
Streams are divided into a number of partitions for scalability. Partitions allow you to distribute a stream by splitting messages across multiple nodes (or brokers). Each partition can be placed on a separate machine to allow multiple consumers to read a stream in parallel. Multiple consumers can read from any partition regardless of where the partition is hosted.
A consumer can read messages from one or more streams. Each message within a stream is marked with an offset value, so a consumer can pick up where it left off if it is interrupted.
You can use the Streaming service by:
A:Creating a stream using the Console or API.
B:Using a producer to publish data to the stream.
C:Building consumers to read and process stream using the GetMessages API . .
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/Streaming/Concepts/streamingoverview.htm

Explanation
Kubernetes cluster is a group of nodes. The nodes are the machines running applications. Each node can be a physical machine or a virtual machine. The node’scapacity (its number of CPUs and amount of memory) is defined when the node is created. A cluster comprises:
– one or more master nodes (for high availability, typically there will be a number of master nodes)
– one or more worker nodes (sometimes known asminions)
Connecting to Worker Nodes Using SSH
If you provided a public SSH key when creating the node pool in a cluster, the public key is installed on all worker nodes in the cluster. On UNIX and UNIX-like platforms (including Solaris and Linux), you canthen connect through SSH to the worker nodes using the ssh utility (an SSH client) to perform administrative tasks.
Note the following instructions assume the UNIX machine you use to connect to the worker node:
Has the ssh utility installed.
Has access tothe SSH private key file paired with the SSH public key that was specified when the cluster was created.
How to connect to worker nodes using SSH depends on whether you specified public or private subnets for the worker nodes when defining the node poolsin the cluster.
Connecting to Worker Nodes in Public Subnets Using SSH
Before you can connect to a worker node in a public subnet using SSH, you must define an ingress rule in the subnet’s security list to allow SSH access. The ingress rule must allow access to port 22 on worker nodes from source 0.0.0.0/0 and any source port To connect to a worker node in a public subnet through SSH from a UNIX machine using the ssh utility:
1- Find out the IP address of the worker node to which you want to connect. You can do this in a number of ways:
Using kubectl. 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 upyour own kubeconfig file. You cannot access a cluster using a kubeconfig file that a different user set up.
See Setting Up Cluster Access. Then in a terminal window, enter kubectl get nodes to see the public IP addresses of worker nodes in node pools in the cluster.
Using the Console. In the Console, display the Cluster List page and then select the cluster to which the worker node belongs. On the Node Pools tab, click the name of the node pool to which the worker node belongs. On the Nodes tab, you see the public IP address of every worker node in the node pool.
Using the REST API. Use the ListNodePools operation to see the public IP addresses of worker nodes in a node pool.
2- In the terminal window, enter ssh opc@<node_ip_address> to connect to the worker node, where <node_ip_address> isthe IP address of the worker node that you made a note of earlier. For example, you might enter ssh [email protected].
Note that if the SSH private key is not stored in the file or in the path that the ssh utility expects (for example, the ssh utility mightexpect the private key to be stored in ~/.ssh/id_rsa), you must explicitly specify the private key filename and location in one of two ways:
Use the -i option to specify the filename and location of the private key. For example, ssh -i
~/.ssh/my_keys/my_host_key_filename [email protected]
Add the private key filename and location to an SSH configuration file, either the client configuration file (~/.ssh/config) if it exists, or the system-wide client configuration file (/etc/ssh/ssh_config). For example, youmight add the following:
Host 192.0.2.254 IdentityFile ~/.ssh/my_keys/my_host_key_filename
For more about the ssh utility’s configuration file, enter man ssh_config Note also that permissions on the private key file must allow you read/write/execute access, but prevent other users from accessing the file. For example, to set appropriate permissions, you might enter chmod 600
~/.ssh/my_keys/my_host_key_filename. If permissions are not set correctly and the private key file is accessible to other users, thessh utility will simply ignore the private key file.
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/ContEng/Tasks/contengconnectingworkernodesusingssh.htm

Explanation
Authorization Header
The Oracle Cloud Infrastructure signature uses the “Signature” Authentication scheme (with an Authorization header), and not the Signature HTTP header.
Required Credentials and OCIDs
You need an APIsigning key in the correct format. See Required Keys and OCIDs.
You also need the OCIDs for your tenancy and user. See Where to Get the Tenancy’s OCID and User’s OCID.
Summary of Signing Steps
In general, these are the steps required to sign a request:
Form the HTTPS request (SSL protocolTLS 1.2 is required).
Create the signing string, which is based on parts of the request.
Create the signature from the signing string, using your private key and the RSA-SHA256 algorithm.
Add the resulting signature and other required information to the Authorization header in the request.
References:
https://docs.cloud.oracle.com/en-us/iaas/Content/Streaming/Concepts/streamingoverview.htm
https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/signingrequests.htm

Explanation
Using Blue-Green Deployment to Reduce Downtime and Risk:
>Blue-green deployment is a technique that reduces downtime and risk by running two identical production environments called Blue and Green. At any time, only one of the environments is live, with the live environment serving all production traffic. For this example, Blue is currently live and Green is idle.
This technique can eliminate downtime due to app deployment. In addition, blue-green deployment reduces risk: if something unexpected happens with your new version on Green, you can immediately roll back to the last version by switching back to Blue.

>Canary deployments are a pattern for rolling out releases to a subset of users or servers. The idea is to first deploy the change to a small subset of servers, test it, and then roll the change out to the rest of the servers.
The canary deployment serves as an early warning indicator with less impact on downtime: if the canary deployment fails, the rest of the servers aren’t impacted.
>A/B testing is a way to compare two versions of a singlevariable, typically by testing a subject’s response to variant A against variant B, and determining which of the two variants is more effective
>Rolling update offers a way to deploy the new version of your application gradually across your cluster.
References:
https://docs.cloudfoundry.org/devguide/deploy-apps/blue-green.html

Explanation
Service Choreography
Service choreography is a global description of the participating services, which is defined by exchange of messages, rules of interactionand agreements between two or more endpoints. Choreography employs a decentralized approach for service composition. the decision logic is distributed, with no centralized point.

Choreography, in contrast, does not rely on a central coordinator. and all participants in the choreography need to be aware of the business process, operations to execute, messages to exchange, and the timing of message exchanges.
References:
https://stackoverflow.com/questions/4127241/orchestration-vs-choreography/33316988