Quiz Oracle Cloud Infrastructure Developer 2020 Associate

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, including 400Mbps 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: <value>
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

This pattern isolates an operation that makes calls to multiple back-end microservices, centralizing its
logic into a specialized microservice.

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 contains the 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
user set up.
2- In a terminal window, enter:
$ kubectl create secret docker-registry <secret-name> --docker-server=<region-key>.ocir.io --docker-
username='<tenancy-namespace>/<oci-username>' --docker-password='<oci-auth-token>' --docker-
email='<email-address>' where:
<secret-name> is a name of your choice, that you will use in the manifest file to refer to the secret .
For example, ocirsecret
<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
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, the namespace string might be the same as the tenancy name in
all lower-case letters (for example, acme-dev).
<oci-username> is the username to use when pulling the image. The username must have access to
the tenancy specified by <tenancy-name>. For example, [email protected] . If your tenancy is
federated with Oracle Identity Cloud Service, use the format oracleidentitycloudservice/<username>
<oci-auth-token> is the auth token of the user specified by <oci-username>. For example,
k]j64r{1sJSSF-;)K8
<email-address> is an email address. An email address is required, but it doesn't matter what you
specify. For example, [email protected]
- You have to specify the image to pull from Oracle Cloud Infrastructure Registry, including the
repository location and the Docker registry secret to use, in the application's manifest file.

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.
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.
A/B testing is a way to compare two versions of a single variable, typically by testing a subject's
response to variant A against variant B, and determining which of the two variants is more effective A
rolling update offers a way to deploy the new version of your application gradually across your
cluster.

The serverless and elastic architecture of Oracle Functions means there's no infrastructure
administration or software administration for you to perform. You don't provision or maintain
compute instances, and operating system software patches and upgrades are applied automatically.
Oracle Functions simply ensures your app is highly-available, scalable, secure, and monitored. With
Oracle Functions, you can write code in Java, Python, Node, Go, and Ruby (and for advanced use
cases, bring your own Dockerfile, and Graal VM). You can then deploy your code, call it directly or
trigger it in response to events, and get billed only for the resources consumed during the execution.

Troubleshooting Oracle Functions
If you encounter an unexpected error when using an Fn Project CLI command, you can find out more
about the problem by starting the command with the string DEBUG=1 and running the command
again. For example:
$ DEBUG=1 fn invoke helloworld-app helloworld-func
Note that DEBUG=1 must appear before the command, and that DEBUG must be in upper case.

Kubectl explain to List the fields for supported resources
https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#explain

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 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.
The data 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 in a 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 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 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.