Welcome to Using Oorchestrations v2 in Oracle Compute Cloud Service. In this
demonstration we'll use orchestrations v2 to create an instance and set up all
the required networking objects that enable us to connect to the instance
using SSH. In this orchestration, we'll create an IP network and add an
interface of the instance to the IP network. We'll also create a vNICset, a
security protocol, a security rule, and an access control list or ACL. This will
enable us to connect to the instance using a previously created SSH key. First,
we'll look at the orchestration file, which is in JSON format. With
orchestrations v2, there are several features that we can
use when creating orchestrations. One important feature is the desired state
of the orchestration, which indicates whether we want the objects to be
created immediately when we upload the orchestration. In this example, the
desired state is specified as active, which instructs the system to create the
objects immediately. For each object that we define in an orchestration, we can
specify a label and a description. The label provides a reference ID, which must
be unique in the orchestration. We use a label to reference an object in other
objects. For example, if we create a storage volume, we can attach it to an
instance by referencing the storage volume's label and its name field in the
instance definition. The type field indicates the kind of object to create.
In this case, we're creating a storage volume, so the fields within the template
define the storage volume. The fields in the template vary depending on the
type of object that we want to create. Effectively, any information we specify
in a template is used to create the underlying object. We also have the
ability to mark individual objects as persistent. This is useful when we want
to tear down some, but not all, of the objects defined in an orchestration. If
we specify that all storage volumes should be persistent, then when we
suspend the orchestration, nonpersistent objects such as instances are deleted,
but storage volumes and the data stored on them or not.
For example, this setup would allow us to modify an instance without compromising
our data. Let's explore an example of object
referencing. In this orchestration, when we define the vNICset, we refer to the
ACL that we also create in this orchestration. We do this by specifying
the name of the ACL in the applied ACLs field. Consider the security rule that
we're defining here. Instead of specifying the name of the ACL, we
reference the label and the name field of the ACL. When we use object references
like this we don't need to specify relationships between objects, because
references are implicit relationships. For example, if an instance references
multiple objects including storage volumes, IP networks, IP address
reservations, and so on, the orchestration waits for all of these reference objects
to be created before launching the instance. In this orchestration, we define
a number of different types of objects. First we define storage volumes. We also
add an SSH key, which we previously created. This is the value of the SSH
public key. When we connect to this instance, the corresponding SSH private
key is used to authenticate access to the instance. Next, we define networking
objects. We create an IP network that we'll add the instance to, and we create
an ACL and a vNIC set. We also create a security protocol and a security rule.
The security rule uses the security protocol to allow access to instances
that have an interface in the destination vNICset. The ACL is used
to apply a set of security rules to a vNICset. Next, we create a public IP
reservation. This provides the public IP address that we'll use to connect to the
instance. Note that we set persistence to true for most of the objects in this
orchestration, including the IP network the security rule and ACL, and the public
IP address. This ensures that if we ever shut down the instance, none of the
networking is disturbed. With the IP address reservation set to be persistent,
the public IP address of the instance won't change if we suspend the
orchestration and restart it later. And finally we create the instance. Note that
most of the objects that the instance depends upon, such as storage
volumes, the vNICset, and the SSH key, are included in the instance definition
by using object references, that is, by referencing their label and name field.
This ensures that the instance is launched only when all of the referenced
objects are ready. Now that the orchestration file is complete, let's
upload it using the web console. Because we specified the desired state as active,
the orchestration starts immediately. While the orchestration is creating the
objects, its status is displayed as starting. When all of the objects have
been created, the orchestration status changes to ready. As the orchestration
starts, objects defined by the orchestration are created. The storage page shows us
that the storage volumes defined in the orchestration are now online. The IP
networks page lists the IP network that we defined in the orchestration. On the
virtual NIC sets page we see two vNICsets, vnicset1 and default.
vnicset1 is the vNICset that we defined in the orchestration. The default vNICset
is created out of the box and a default ACL is applied to this vNICset.
This allows traffic across all vNICs in the default vNICset. The
instance we defined in the orchestration hasn't been added to the default vNICset,
because we explicitly specified that it should be added to vnicset1.
On the access control list page, we see the default ACL as well as the ACL that we
defined in the orchestration, Acl1. The default ACL applies the default security
rules to enable traffic across instances in the default vNICset. Acl1
contains the ingress security rule to allow SSH access. Next, let's go to the
security protocols page. Here we see the security protocol that we defined in the
orchestration. And finally, here's the IP address reservation that we created in
the orchestration. The instances page shows us that the instance is running.
With all of the network objects in place, let's log into this instance using SSH.
We can look up the public IP address of our instance on the IP reservations page.
To start an SSH session on a Windows system, we launch PuTTY and enter the
public IP address of the instance. We enter the passphrase for the SSH key and
we're done. We've logged into the instance as the default OPC user. We can
now proceed to customize the instance, install apps, and use the instance to run
workloads as required. Now, let's say we want to stop this instance, but we don't
want to delete the storage volumes associated with it. With orchestrations v2,
we can suspend the orchestration to stop nonpersistent objects. Remember
that we defined the IP network and other networking objects, such as the security
rule and ACL, to be persistent. Of course, to ensure data isn't lost, we also defined
the storage volumes as persistent. So when we suspend this orchestration, no
persistent objects are deleted. Later we can restart the orchestration to
re-create the instance and any other nonpersistent objects that were deleted
when we suspended the orchestration. Or, if we no longer need any of the objects,
we can either stop or delete the orchestration. If we stop the
orchestration, all objects are deleted but the orchestration itself is still
available and we can start it later. If we delete the orchestration, all of the
objects created by the orchestration are deleted and then the orchestration
itself is also deleted. For more information about orchestrations v2,
see the documentation. Thanks for watching!