adding oci-ons-compute-shape-increase-python

Author: gregvers

samples/oci-ons-compute-shape-increase-python/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+__pycache__
+test.py

samples/oci-ons-compute-shape-increase-python/README.md

@@ -0,0 +1,132 @@
+# Automatically Resize VMs
+Automatically resize VMs that exceed memory consumption. The function code is referenced in the OCI documentation at https://docs.cloud.oracle.com/en-us/iaas/Content/Notification/Tasks/scenarioa.htm.
+
+This use case involves writing a function to resize VMs and creating an alarm  that sends a message to that function. When the alarm fires, the Notifications service sends the alarm message to the destination topic, which then fans out to the topic's subscriptions. In this scenario, the topic's subscriptions include the function as well as your email. The function is invoked on receipt of the alarm message. 
+
+![ONS to Functions](https://docs.cloud.oracle.com/en-us/iaas/Content/Resources/Images/notifications-scenarioA.png)
+
+As you make your way through this tutorial, look out for this icon ![user input icon](./images/userinput.png).
+Whenever you see it, it's time for you to perform an action.
+
+
+## Prerequisites
+Before you deploy this sample function, make sure you have run step A, B and C of the [Oracle Functions Quick Start Guide for Cloud Shell](https://www.oracle.com/webfolder/technetwork/tutorials/infographics/oci_functions_cloudshell_quickview/functions_quickview_top/functions_quickview/index.html)
+* A - Set up your tenancy
+* B - Create application
+* C - Set up your Cloud Shell dev environment
+
+
+## List Applications 
+Assuming your have successfully completed the prerequisites, you should see your 
+application in the list of applications.
+```
+fn ls apps
+```
+
+
+## Create or Update your Dynamic Group
+In order to use other OCI Services, your function must be part of a dynamic group. For information on how to create a dynamic group, refer to the [documentation](https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingdynamicgroups.htm#To).
+
+When specifying the *Matching Rules*, we suggest matching all functions in a compartment with:
+```
+ALL {resource.type = 'fnfunc', resource.compartment.id = 'ocid1.compartment.oc1..aaaaaxxxxx'}
+```
+Please check the [Accessing Other Oracle Cloud Infrastructure Resources from Running Functions](https://docs.cloud.oracle.com/en-us/iaas/Content/Functions/Tasks/functionsaccessingociresources.htm) for other *Matching Rules* options.
+
+
+## Create or Update IAM Policies
+Create a new policy that allows the dynamic group to *use instances*.
+
+![user input icon](./images/userinput.png)
+
+Your policy should look something like this:
+```
+Allow dynamic-group <dynamic-group-name> to use instances in compartment <compartment-name>
+```
+For more information on how to create policies, check the [documentation](https://docs.cloud.oracle.com/iaas/Content/Identity/Concepts/policysyntax.htm).
+
+
+## Review and customize your function
+Review the following files in the current folder:
+* the code of the function, [func.py](./func.py)
+* its dependencies, [requirements.txt](./requirements.txt)
+* the function metadata, [func.yaml](./func.yaml)
+
+The following piece of code in [func.py](./func.py) should be updated to match your needs:
+```
+    if  current_shape == "VM.Standard1.1":
+        new_shape = "VM.Standard2.1"
+    elif current_shape == "VM.Standard2.1":
+        new_shape = "VM.Standard2.2"
+```
+
+The code in [list_vm_shapes.py](./list_vm_shapes.py) can be used to improve the logic of VM shape selection.
+
+
+## Deploy the function
+In Cloud Shell, run the fn deploy command to build the function and its dependencies as a Docker image,
+push the image to OCIR, and deploy the function to Oracle Functions in your application.
+
+![user input icon](./images/userinput.png)
+```
+fn -v deploy --app <your app name>
+```
+e.g.
+```
+fn -v deploy --app myapp
+```
+
+
+## Configure Oracle Notification Service
+This section walks through creating an alarm using the Console and then updating the ONS topic created with the alarm.
+
+![user input icon](./images/userinput.png)
+
+On the OCI console, navigate to *Monitoring* > *Alarm Definitions*. Click *Create Alarm*.
+
+On the Create Alarm page, under Define alarm, set up your threshold: 
+
+Metric description: 
+* Compartment: (select the compartment that contains your VM)
+* Metric Namespace: oci_computeagent
+* Metric Name: MemoryUtilization
+* Interval: 1m
+* Statistic: Max 
+
+Trigger rule:
+* Operator: greater than
+* Value: 90  (or lower for testing purposes)
+* Trigger Delay Minutes: 1
+
+Select your function under Notifications, Destinations:
+* Destination Service: Notifications Service
+* Compartment: (select the compartment where you want to create the topic and associated subscriptions)
+
+Topic: Click *Create a topic*
+* Topic Name: Alarm Topic
+* Subscription Protocol: Function
+* Function Compartment: (select the compartment that contains your function)
+* Function Application: (select the application that contains your function)
+* Function: (select your function)
+* Click *Create topic and subscription*
+
+Click Save alarm.
+
+
+## Test ONS > Fn
+First, test the function indivudually.
+
+![user input icon](./images/userinput.png)
+
+Update section "resourceId" in [test-alarm.json](./test-alarm.json) with the OCID of the instance you want to update.
+
+Invoke the function as follows:
+```
+cat test-alarm.json | fn invoke <your app name> <function name>
+```
+e.g.:
+```
+cat test-alarm.json | fn invoke myapp oci-ons-compute-shape-increase-python
+```
+
+Now, the whole flow can be tested. Connect to an instance in the compartment where the alarm is active, and stress the memory utilization with the *stress* utility for example.

samples/oci-ons-compute-shape-increase-python/func.py

@@ -0,0 +1,73 @@
+#
+# oci-ons-compute-shape-increase-python version 1.0.
+#
+# Copyright (c) 2020 Oracle, Inc.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+#
+
+import io
+import json
+import oci
+
+from fdk import response
+
+def increase_compute_shape(instance_id, alarm_msg_shape):
+    signer = oci.auth.signers.get_resource_principals_signer()
+    compute_client = oci.core.ComputeClient(config={}, signer=signer)
+    current_shape = compute_client.get_instance(instance_id).data.shape
+    print("INFO: current shape for Instance {0}: {1}".format(instance_id,current_shape), flush=True)
+    if current_shape != alarm_msg_shape:
+        return "The shape of Instance {} differs from the Alarm message".format(instance_id)
+    # improve the logic below to handle more scenarios, make sure the shapes you select are available in the region and AD
+    if  current_shape == "VM.Standard1.1":
+        new_shape = "VM.Standard2.1"
+    elif current_shape == "VM.Standard2.1":
+        new_shape = "VM.Standard2.2"
+    else:
+        return "Instance {0} cannot get a bigger shape than its current shape {1}".format(instance_id,current_shape)
+    print("INFO: new shape for Instance {0}: {1}".format(instance_id,new_shape), flush=True)
+    try:
+        update_instance_details = oci.core.models.UpdateInstanceDetails(shape=new_shape)
+        resp = compute_client.update_instance(instance_id=instance_id, update_instance_details=update_instance_details)
+        print(resp, flush=True)
+    except Exception as ex:
+        print('ERROR: cannot update instance {}'.format(instance_id), flush=True)
+        raise
+    return "The shape of Instance {} is updated, the instance is rebooting...".format(instance_id)
+
+def handler(ctx, data: io.BytesIO=None):
+    alarm_msg = {}
+    message_id = func_response = ""
+    try:
+        headers = ctx.Headers()
+        message_id = headers["x-oci-ns-messageid"]
+    except Exception as ex:
+        print('ERROR: Missing Message ID in the header', ex, flush=True)
+        raise
+    print("INFO: Message ID = ", message_id, flush=True)
+    # the Message Id can be stored in a database and be used to check for duplicate messages
+    try:
+        alarm_msg = json.loads(data.getvalue())
+        print("INFO: Alarm message: ")
+        print(alarm_msg, flush=True)
+    except (Exception, ValueError) as ex:
+        print(str(ex), flush=True)
+
+    if alarm_msg["type"] == "OK_TO_FIRING":
+        if alarm_msg["alarmMetaData"][0]["dimensions"]:
+            alarm_metric_dimension = alarm_msg["alarmMetaData"][0]["dimensions"][0]   #assuming the first dimension matches the instance to resize
+            print("INFO: Instance to resize: ", alarm_metric_dimension["resourceId"], flush=True)
+            func_response = increase_compute_shape(alarm_metric_dimension["resourceId"], alarm_metric_dimension["shape"])
+            print("INFO: ", func_response, flush=True)
+        else:
+            print('ERROR: There is no metric dimension in this alarm message', flush=True)
+            func_response = "There is no metric dimension in this alarm message"
+    else:
+        print('INFO: Nothing to do, alarm is not FIRING', flush=True)
+        func_response = "Nothing to do, alarm is not FIRING"
+
+    return response.Response(
+        ctx, 
+        response_data=func_response,
+        headers={"Content-Type": "application/json"}
+    )

samples/oci-ons-compute-shape-increase-python/func.yaml

@@ -0,0 +1,6 @@
+schema_version: 20180708
+name: oci-ons-compute-shape-increase-python
+version: 0.0.1
+runtime: python
+entrypoint: /python/bin/fdk /function/func.py handler
+memory: 256

samples/oci-ons-compute-shape-increase-python/images/userinput.png

@@ -0,0 +1,19 @@
+#
+# oci-ons-compute-shape-increase-python version 1.0.
+#
+# Copyright (c) 2020 Oracle, Inc.
+# Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
+#
+
+def list_vm_shapes(compute_client, compartment_id, availability_domain):
+    list_shapes_response = oci.pagination.list_call_get_all_results(
+            compute_client.list_shapes,
+            compartment_id,
+            availability_domain=availability_domain
+        )
+    vm_shapes_only = list(filter(lambda shape: shape.shape.startswith("VM"), list_shapes_response.data))
+    available_shapes = list(map(lambda shape: shape.shape, vm_shapes_only))
+    return available_shapes
+
+    #available_shapes = list_vm_shapes(compute_client, compartment_id, availability_domain)
+    #print("available shapes: ", available_shapes, flush=True)

samples/oci-ons-compute-shape-increase-python/list_vm_shapes.py

@@ -0,0 +1,2 @@
+fdk
+oci

samples/oci-ons-compute-shape-increase-python/requirements.txt

@@ -0,0 +1,30 @@
+{
+  "dedupeKey": "501f01d7-20cd-5958-a5ca-61ba0ddebd8d",
+  "title": "TEST-high-memory",
+  "body": "High memory usage",
+  "type": "OK_TO_FIRING",
+  "severity": "CRITICAL",
+  "timestampEpochMillis": 1582324860000,
+  "alarmMetaData": [
+    {
+      "id": "ocid1.alarm.oc1.iad.exampleuniqueID",
+      "status": "FIRING",
+      "severity": "CRITICAL",
+      "query": "MemoryUtilization[1m]{resourceId = \"ocid1.instance.oc1.iad.exampleuniqueID\"}.max() > 20",
+      "totalMetricsFiring": 1,
+      "dimensions": [
+        {
+          "instancePoolId": "Default",
+          "resourceDisplayName": "myinstance1",
+          "faultDomain": "FAULT-DOMAIN-2",
+          "resourceId": "ocid1.instance.oc1.iad.anuwcljsato5mnsdjasdaskgdasujggsmihhzf6ae26mxnxucd7pcwa3rneq",
+          "availabilityDomain": "xqgA:US-ASHBURN-AD-1",
+          "imageId": "ocid1.image.oc1.iad.exampleuniqueID",
+          "region": "us-ashburn-1",
+          "shape": "VM.Standard.E2.1"
+        }
+      ]
+    }
+  ],
+  "version": 1.0
+}