Merge branch 'main' into aml

compute/disks/createComputeHyperdiskFromPool.js

@@ -33,11 +33,11 @@ async function main() {
   // Project ID or project number of the Google Cloud project you want to use.
   const projectId = await disksClient.getProjectId();
   // The zone where your VM and new disk are located.
-  const zone = 'europe-central2-b';
+  const zone = 'us-central1-a';
   // The name of the new disk
-  const diskName = 'disk-name-from-pool';
+  const diskName = 'disk-from-pool-name';
   // The name of the storage pool
-  const storagePoolName = 'storage-pool-name-hyperdisk';
+  const storagePoolName = 'storage-pool-name';
   // Link to the storagePool you want to use. Use format:
   // https://www.googleapis.com/compute/v1/projects/{projectId}/zones/{zone}/storagePools/{storagePoolName}
   const storagePool = `https://www.googleapis.com/compute/v1/projects/${projectId}/zones/${zone}/storagePools/${storagePoolName}`;

compute/reservations/createReservationFromProperties.js

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+'use strict';
+
+async function main() {
+  // [START compute_reservation_create]
+  // Import the Compute library
+  const computeLib = require('@google-cloud/compute');
+  const compute = computeLib.protos.google.cloud.compute.v1;
+
+  // Instantiate a reservationsClient
+  const reservationsClient = new computeLib.ReservationsClient();
+  // Instantiate a zoneOperationsClient
+  const zoneOperationsClient = new computeLib.ZoneOperationsClient();
+
+  /**
+   * TODO(developer): Update these variables before running the sample.
+   */
+  // The ID of the project where you want to reserve resources and where the instance template exists.
+  const projectId = await reservationsClient.getProjectId();
+  // The zone in which to reserve resources.
+  const zone = 'us-central1-a';
+  // The name of the reservation to create.
+  const reservationName = 'reservation-01';
+  // The number of VMs to reserve.
+  const vmsNumber = 3;
+  // Machine type to use for each VM.
+  const machineType = 'n1-standard-4';
+
+  async function callCreateComputeReservationFromProperties() {
+    // Create specific reservation for 3 VMs that each use an N1 predefined machine type with 4 vCPUs.
+    const specificReservation = new compute.AllocationSpecificSKUReservation({
+      count: vmsNumber,
+      instanceProperties: {
+        machineType,
+        // To have the reserved VMs use a specific minimum CPU platform instead of the zone's default CPU platform.
+        minCpuPlatform: 'Intel Skylake',
+        // If you want to attach GPUs to your reserved N1 VMs, update and uncomment guestAccelerators if needed.
+        guestAccelerators: [
+          {
+            // The number of GPUs to add per reserved VM.
+            acceleratorCount: 1,
+            // Supported GPU model for N1 VMs. Ensure that your chosen GPU model is available in the zone,
+            // where you want to reserve resources.
+            acceleratorType: 'nvidia-tesla-t4',
+          },
+        ],
+        // If you want to add local SSD disks to each reserved VM, update and uncomment localSsds if needed.
+        // You can specify up to 24 Local SSD disks. Each Local SSD disk is 375 GB.
+        localSsds: [
+          {
+            diskSizeGb: 375,
+            // The type of interface you want each Local SSD disk to use. Specify one of the following values: NVME or SCSI.
+            // Make sure that the machine type you specify for the reserved VMs supports the chosen disk interfaces.
+            interface: 'NVME',
+          },
+        ],
+      },
+    });
+
+    // Create a reservation.
+    const reservation = new compute.Reservation({
+      name: reservationName,
+      zone,
+      specificReservation,
+    });
+
+    const [response] = await reservationsClient.insert({
+      project: projectId,
+      reservationResource: reservation,
+      zone,
+    });
+
+    let operation = response.latestResponse;
+
+    // Wait for the create reservation operation to complete.
+    while (operation.status !== 'DONE') {
+      [operation] = await zoneOperationsClient.wait({
+        operation: operation.name,
+        project: projectId,
+        zone: operation.zone.split('/').pop(),
+      });
+    }
+
+    const createdReservation = (
+      await reservationsClient.get({
+        project: projectId,
+        zone,
+        reservation: reservationName,
+      })
+    )[0];
+
+    console.log(JSON.stringify(createdReservation));
+  }
+
+  await callCreateComputeReservationFromProperties();
+  // [END compute_reservation_create]
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exitCode = 1;
+});

compute/test/createComputeHyperdiskFromPool.test.js

@@ -20,96 +20,82 @@ const path = require('path');
 const {assert} = require('chai');
 const {after, before, describe, it} = require('mocha');
 const cp = require('child_process');
-const {DisksClient, StoragePoolsClient} = require('@google-cloud/compute').v1;
+const {DisksClient, StoragePoolsClient, ZoneOperationsClient} =
+  require('@google-cloud/compute').v1;
 
 const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
 const cwd = path.join(__dirname, '..');
 
-describe('Create compute hyperdisk from pool', async () => {
-  const diskName = 'disk-name-from-pool';
-  const zone = 'europe-central2-b';
-  const storagePoolName = 'storage-pool-name-hyperdisk';
+async function cleanupResources(projectId, zone, diskName, storagePoolName) {
   const disksClient = new DisksClient();
   const storagePoolsClient = new StoragePoolsClient();
+  const zoneOperationsClient = new ZoneOperationsClient();
+  // Delete disk attached to storagePool
+  const [diskResponse] = await disksClient.delete({
+    project: projectId,
+    disk: diskName,
+    zone,
+  });
+
+  let diskOperation = diskResponse.latestResponse;
+
+  // Wait for the delete disk operation to complete.
+  while (diskOperation.status !== 'DONE') {
+    [diskOperation] = await zoneOperationsClient.wait({
+      operation: diskOperation.name,
+      project: projectId,
+      zone: diskOperation.zone.split('/').pop(),
+    });
+  }
+
+  const [poolResponse] = await storagePoolsClient.delete({
+    project: projectId,
+    storagePool: storagePoolName,
+    zone,
+  });
+  let poolOperation = poolResponse.latestResponse;
+
+  // Wait for the delete pool operation to complete.
+  while (poolOperation.status !== 'DONE') {
+    [poolOperation] = await zoneOperationsClient.wait({
+      operation: poolOperation.name,
+      project: projectId,
+      zone: poolOperation.zone.split('/').pop(),
+    });
+  }
+}
+
+describe('Create compute hyperdisk from pool', async () => {
+  const diskName = 'disk-from-pool-name';
+  const zone = 'us-central1-a';
+  const storagePoolName = 'storage-pool-name';
+  const disksClient = new DisksClient();
   let projectId;
 
   before(async () => {
     projectId = await disksClient.getProjectId();
 
     // Ensure resources are deleted before attempting to recreate them
     try {
-      await disksClient.delete({
-        project: projectId,
-        disk: diskName,
-        zone,
-      });
-    } catch (err) {
-      // Should be ok to ignore (resource doesn't exist)
-      console.error(err);
-    }
-
-    try {
-      await storagePoolsClient.delete({
-        project: projectId,
-        storagePool: storagePoolName,
-        zone,
-      });
+      await cleanupResources(projectId, zone, diskName, storagePoolName);
     } catch (err) {
-      // Should be ok to ignore (resource doesn't exist)
+      // Should be ok to ignore (resources do not exist)
       console.error(err);
     }
-
-    await storagePoolsClient.insert({
-      project: projectId,
-      storagePoolResource: {
-        name: storagePoolName,
-        poolProvisionedCapacityGb: 10240,
-        poolProvisionedIops: 10000,
-        poolProvisionedThroughput: 1024,
-        storagePoolType: `projects/${projectId}/zones/${zone}/storagePoolTypes/hyperdisk-balanced`,
-        capacityProvisioningType: 'advanced',
-        zone,
-      },
-      zone,
-    });
   });
 
   after(async () => {
-    // Trying to delete the disk too quickly seems to fail
-    const deleteDisk = async () => {
-      setTimeout(async () => {
-        await disksClient.delete({
-          project: projectId,
-          disk: diskName,
-          zone,
-        });
-      }, 120 * 1000); // wait two minutes
-    };
-
-    try {
-      await deleteDisk();
-    } catch {
-      // Try one more time after repeating the delay
-      await deleteDisk();
-    }
+    await cleanupResources(projectId, zone, diskName, storagePoolName);
+  });
 
-    // Need enough time after removing the disk before removing the pool
-    const deletePool = async () => {
-      setTimeout(async () => {
-        await storagePoolsClient.delete({
-          project: projectId,
-          storagePool: storagePoolName,
-          zone,
-        });
-      }, 120 * 1000); // wait two minutes
-    };
+  it('should create a new storage pool', () => {
+    const response = JSON.parse(
+      execSync('node ./disks/createComputeHyperdiskPool.js', {
+        cwd,
+      })
+    );
 
-    try {
-      await deletePool();
-    } catch {
-      // Try one more time after repeating the delay
-      await deletePool();
-    }
+    assert.equal(response.name, storagePoolName);
   });
 
   it('should create a new hyperdisk from pool', () => {