Create a Compute Instance

Before You Begin

To successfully perform this tutorial, you must have the following:

1. Prepare

Prepare your environment for creating a compute instance. Also, collect all the information you need to complete the tutorial.

Create SSH Encryption Keys

Create ssh encryption keys to connect to your compute instance.

Open a terminal window:
- MacOS or Linux: Open a terminal window in the directory where you want to store your keys.
- Windows: Right-click the directory where you want to store your keys and select Git Bash Here.
Note

If you're using Windows Subsystem for Linux (WSL), ensure that the directory for the keys is directly on your Linux machine and not in a /mnt folder (windows file system).
Issue the following OpenSSH command:
```
ssh-keygen -t rsa -N "" -b 2048 -C <your-ssh-key-name> -f <your-ssh-key-name>
```
The command generates some random text art used to generate the keys. When complete, you have two files:
- The private key file: <your-ssh-key-name>
- The public key file: <your-ssh-key-name>.pub
You use these files to connect to your compute instance.

You have generated the required encryption keys.

For detailed information on generating ssh encryption keys, see Creating a Key Pair.

Create a Virtual Cloud Network (VCN)

Gather Required Information

Collect and copy the information you need into your notepad.

Compartment name
Compartment ID
Subnet ID
Source ID (image of compute instance)
Shape (compute instance)
SSH Authorized Key (public key path)
Private SSH Key Path

For steps to collect this information, see the following table.

Item	Steps to collect item
Compartment name	Reference the completed tutorial Create a Compartment.
Compartment ID	In the Console search bar, enter `<your-compartment-name>`. Select `<your-compartment-name>` in the search results. Select Copy next to the OCID.
Instance display name	Name of your choice.
Subnet ID	In the Console: Open the navigation menu , select Networking, and then select Virtual cloud networks. Select `<your-vcn-name>` from Create a Virtual Cloud Network (VCN). Select Subnets. Select `<your-compartment-name>` to show subnets in your compartment. From the Actions menu () for the public subnet, select Copy OCID.
Source ID (image of compute instance)	In the Console navigation bar, find your region. See Working in Regions. Go to Image Release Notes. Select Ubuntu 24.04. The list of images for Ubuntu 24.04 opens. Select the latest image: Canonical-Ubuntu-24.04-<date>. The page lists image OCIDs. Find the image for your region and copy the image's OCID. Note: Ensure that you select a commercial OCID without `gov` in its OCID.
Shape and configuration (compute instance)	Shape: `VM.Standard.E5.Flex` OCPUs: 1 Memory (GBs): 12 Note: The `VM.Standard.E5.Flex` requires values for OCPUs and memory. To select a different shape, go to Virtual Machine (VM) Shapes.
SSH Authorized Key (public key path)	Reference the completed section, Create SSH Encryption Keys. Use this path when you set up the compute instance.
Private SSH Key Path	Reference the completed section, Create SSH Encryption Keys. Use this private key when you connect to your compute instance.

Add Resource Policy

If your username is in the Administrators group, then skip this section. Otherwise, ask your administrator to add the following policy to your tenancy:

allow group <a-group-your-username-belongs-to> to manage all-resources in compartment <your-compartment-name>

With this privilege, you can manage all resources in your compartment, giving you administrative rights in that compartment.

Steps to Add the Policy

2. Create Scripts

Create scripts for authentication, fetching data, creating a compute instance, and printing outputs.

Add Authentication

First, set up a directory for your Terraform scripts. Then copy the provider and versions scripts from the Set Up OCI Terraform tutorial so your Oracle Cloud Infrastructure account can authenticate the scripts running from this directory.

In your $HOME directory, create a directory called tf-compute, and then change to that directory.
```
mkdir tf-compute
```
```
cd tf-compute
```
Copy the provider.tf file into the tf-compute directory.
```
cp ../tf-provider/provider.tf .
```
Copy the versions.tf file into the tf-compute directory.
```
cp ../tf-provider/versions.tf .
```

Fetch Data

Fetch the name of an availability domain from your account. An availability domain is one of the required inputs to create a compute instance.

Copy the availability-domains.tf file into the tf-compute directory.

The availability-domains.tf file was created during the tutorial Set Up OCI Terraform.

cp ../tf-provider/availability-domains.tf .

Example code:

# Source from https://registry.terraform.io/providers/oracle/oci/latest/docs/data-sources/identity_availability_domains

data "oci_identity_availability_domains" "ads" {
  compartment_id = "<tenancy-ocid>"
}

In the tf-compute directory, create a file called outputs.tf.

Note

Ensure that outputs.tf, provider.tf, and availability-domains.tf are in the same directory.

To output the name of the first availability domain in the list of oci_identity_availability_domains, add the following code to outputs.tf.


# The "name" of the availability domain to be used for the compute instance.
output "name-of-first-availability-domain" {
  value = data.oci_identity_availability_domains.ads.availability_domains[0].name
}

Save the outputs.tf file.
Run your scripts with Terraform:
```
terraform init
```
```
terraform plan
```
```
terraform apply
```
When prompted for confirmation, enter yes for your data to be fetched and displayed in the output.
You now have an output with the name of the availability domain to use for your instance.

Example output:
```
name-of-first-availability-domain = QnsC:US-ASHBURN-AD-1
```

Congratulations! You have successfully fetched data from your Oracle Cloud Infrastructure account to use for your compute instance.

Explanation

When you set up Terraform in the first tutorial, Set Up OCI Terraform, the output block included the following line:

value = data.oci_identity_availability_domains.ads.availability_domains

Then, the output was similar to the following:

Outputs:

all-availability-domains-in-your-tenancy = tolist([
  {
    "compartment_id" = "ocid1.tenancy.xxx"
    "id" = "ocid1.availabilitydomain.xxx"
    "name" = "QnsC:US-ASHBURN-AD-1"
  },
  {
    "compartment_id" = "ocid1.tenancy.xxx"
    "id" = "ocid1.availabilitydomain.xxx"
    "name" = "QnsC:US-ASHBURN-AD-2"
  },
  {
    "compartment_id" = "ocid1.tenancy.xxx"
    "id" = "ocid1.availabilitydomain.xxx"
    "name" = "QnsC:US-ASHBURN-AD-3"
  },
])

Now, you want to fetch the name of the first availability domain in the list, to use for the location of your compute instance later:

"name" = "xxxx:US-ASHBURN-AD-1"

The attributes for Data Source: oci_identity_availability_domains are:
- availability_domains, a list with three string attributes:
  - compartment_id
  - id
  - name

Note

Use square brackets to add an index to a list attribute.
Use the index 0 for the first item in a list.
Use a dot after the square brackets followed by an attribute of the list, to specify that attribute.

Example: First item in the list:
value = data.oci_identity_availability_domains.ads.availability_domains[0]
Example: Name of first item in the list:
value = data.oci_identity_availability_domains.ads.availability_domains[0].name

Declare a Compute Resource

Declare an Oracle Cloud Infrastructure compute resource, and then define the specifics for the instance.

Tip

You can save a stack from the Console workflow for creating a compute instance. The stack contains a Terraform configuration that you can use as a reference for the shape and shape configuration. See Creating a Stack from a Resource Creation Page and Getting a Stack's Terraform Configuration.

Create a file called compute.tf.

Add the following code to compute.tf.

resource "oci_core_instance" "ubuntu_instance" {
    # Required
    availability_domain = data.oci_identity_availability_domains.ads.availability_domains[0].name
    compartment_id = "<compartment-ocid>"
    shape = "VM.Standard.E5.Flex"
    shape_config {
        ocpus = "1"
        memory_in_gbs = "12"
    }
    source_details {
        source_id = "<source-ocid>"
        source_type = "image"
    }

    # Optional
    display_name = "<your-ubuntu-instance-name>"
    create_vnic_details {
        assign_public_ip = true
        subnet_id = "<subnet-ocid>"
    }
    metadata = {
        ssh_authorized_keys = file("<ssh-public-key-path>")
    } 
    preserve_boot_volume = false
}

Important

Replace <compartment-ocid>, <source-ocid>, <your-ubuntu-instance-name>, and <subnet-ocid> with the information you collected at Gather Required Information.

For availability domain, use the name you fetched with the data source:

data.oci_identity_availability_domains.ads.availability_domains[0].name

For ssh_authorized_keys, use the following format:
```
file("<ssh-public-key-path>")
```
You can't change its value after you create the VM.

Save the compute.tf file.

Explanation

Add Outputs

Add output blocks to your code to get information about your compute instance after Terraform creates it.

Open the outputs.tf file.
Create an output block for the public IP of the instance:
- The public IP is available after the instance is created.
- Use the public IP to connect to the instance.
- Add the following code to outputs.tf:
```
# Outputs for compute instance

output "public-ip-for-compute-instance" {
  value = oci_core_instance.ubuntu_instance.public_ip
}
```

Add a few more outputs to describe the compute instance:

display_name
id
region
shape
state
ocpus
memory_in_gbs
time_created


output "instance-name" {
  value = oci_core_instance.ubuntu_instance.display_name
}

output "instance-OCID" {
  value = oci_core_instance.ubuntu_instance.id
}

output "instance-region" {
  value = oci_core_instance.ubuntu_instance.region
}

output "instance-shape" {
  value = oci_core_instance.ubuntu_instance.shape
}

output "instance-state" {
  value = oci_core_instance.ubuntu_instance.state
}

output "instance-OCPUs" {
  value = oci_core_instance.ubuntu_instance.shape_config[0].ocpus
}

output "instance-memory-in-GBs" {
  value = oci_core_instance.ubuntu_instance.shape_config[0].memory_in_gbs
}

output "time-created" {
  value = oci_core_instance.ubuntu_instance.time_created
}

Save the outputs.tf file.

Explanation

3. Run Scripts

Run your Terraform scripts to create the compute instance in a compartment in your tenancy. Use your SSH keys to connect to the instance. When you no longer need your instance, destroy it with Terraform.

Create an Instance

Create your compute instance with Terraform:
```
terraform init
```
```
terraform plan
```
```
terraform apply
```
When prompted for confirmation, enter yes, for your resource to be created.
After the instance is created, the outputs that you defined including <your-public-ip-address> are displayed in the output terminal.
(Optional) Watch the instance creation from the Console.
- Open the navigation menu and select Compute. Under Compute, select Instances.
- Select your compartment.
- Watch your instance appear in the list of instances.

Congratulations! You have successfully created a compute instance using Terraform, in your Oracle Cloud Infrastructure account.

References:

Connect to the Instance

From your terminal, enter the outputs for your compute instance:
```
terraform output
```
Copy the public IP address from the outputs.
From your Linux machine, connect to your VM with this ssh command:
```
ssh -i <ssh-private-key-path> ubuntu@<your-public-ip-address>
```
Note

Ensure that your private key is located directly on your Linux (WSL) machine.
Disconnect from the instance:
```
exit
```

Destroy the Instance

(Optional) After you no longer need your compute instance, you can terminate it with the following command:
```
terraform destroy
```
When prompted for confirmation, enter yes.
(Optional) Watch the termination from the Console:
- Open the navigation menu and select Compute. Under Compute, select Instances.
- Select your compartment.
- Watch your instance's state change to Terminating and then Terminated.

What's Next

For the next Terraform tutorial, go to:

Set Up a Simple Infrastructure with OCI Terraform

To explore more information about development with Oracle products, check out these sites:

Oracle Cloud Infrastructure Documentation
Try Free Tier

Create a Compute Instance

Before You Begin

1. Prepare

1. Configuration

Configure VCN

Configure Public Subnet

Configure Private Subnet

2. Review and create

2. Create Scripts

3. Run Scripts

What's Next

Oracle Cloud Infrastructure Documentation Try Free Tier

Create a Compute Instance

Before You Begin 🔗

1. Prepare 🔗

1. Configuration 🔗

Configure VCN 🔗

Configure Public Subnet 🔗

Configure Private Subnet 🔗

2. Review and create 🔗

2. Create Scripts 🔗

3. Run Scripts 🔗

What's Next 🔗

Oracle Cloud Infrastructure Documentation
Try Free Tier

Before You Begin

1. Prepare

1. Configuration

Configure VCN

Configure Public Subnet

Configure Private Subnet

2. Review and create

2. Create Scripts

3. Run Scripts

What's Next