# vm

***

**1. Create a New VM Instance**

```js
const compute = require('@google-cloud/compute');

async function createInstance() {
  // Lists the available machine types in the specified zone.
  const [machineTypes] = await compute.getMachineTypes({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
  });

  // Create a new instance in the specified project and zone.
  const [instance] = await compute.createInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instanceResource: {
      name: 'INSTANCE_NAME',
      disks: [
        {
          initializeParams: {
            diskSizeGb: '250',
            sourceImage: 'projects/debian-cloud/global/images/family/debian-11',
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `projects/${'PROJECT_ID'}/zones/${'europe-central2-b'}/machineTypes/${machineTypes[0]}`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });

  console.log(`Instance ${instance.name} created.`);
}
```

**2. Get Instance Details**

```js
const compute = require('@google-cloud/compute');

async function getInstance() {
  const [instance] = await compute.getInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  console.log(`Instance ${instance.name} details: ${JSON.stringify(instance)}`);
}
```

**3. Start Instance**

```js
const compute = require('@google-cloud/compute');

async function startInstance() {
  const [response] = await compute.startInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  console.log(`Instance ${'INSTANCE_NAME'} started.`);
}
```

**4. Stop Instance**

```js
const compute = require('@google-cloud/compute');

async function stopInstance() {
  const [response] = await compute.stopInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  console.log(`Instance ${'INSTANCE_NAME'} stopped.`);
}
```

**5. Reset Instance**

```js
const compute = require('@google-cloud/compute');

async function resetInstance() {
  const [response] = await compute.resetInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  console.log(`Instance ${'INSTANCE_NAME'} reset.`);
}
```

**6. Delete Instance**

```js
const compute = require('@google-cloud/compute');

async function deleteInstance() {
  await compute.deleteInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  console.log(`Instance ${'INSTANCE_NAME'} deleted.`);
}
```

**7. Create a Disk**

```js
const compute = require('@google-cloud/compute');

async function createDisk() {
  const [disk] = await compute.createDisk({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    diskResource: {
      name: 'DISK_NAME',
      type: 'PERSISTENT',
      sizeGb: '100',
    },
  });

  console.log(`Disk ${disk.name} created.`);
}
```

**8. Get Disk Details**

```js
const compute = require('@google-cloud/compute');

async function getDisk() {
  const [disk] = await compute.getDisk({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    disk: 'DISK_NAME',
  });

  console.log(`Disk ${disk.name} details: ${JSON.stringify(disk)}`);
}
```

**9. Delete Disk**

```js
const compute = require('@google-cloud/compute');

async function deleteDisk() {
  await compute.deleteDisk({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    disk: 'DISK_NAME',
  });

  console.log(`Disk ${'DISK_NAME'} deleted.`);
}
```

**10. Attach Disk to Instance**

```js
const compute = require('@google-cloud/compute');

async function attachDisk() {
  const [instance] = await compute.getInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  await compute.attachDisk({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: instance.name,
    attachedDiskResource: {
      source: `zones/${'europe-central2-b'}/disks/${'DISK_NAME'}`,
    },
  });

  console.log(`Disk ${'DISK_NAME'} attached to instance ${instance.name}.`);
}
```

**11. Detach Disk from Instance**

```js
const compute = require('@google-cloud/compute');

async function detachDisk() {
  const [instance] = await compute.getInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: 'INSTANCE_NAME',
  });

  await compute.detachDisk({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    instance: instance.name,
    deviceName: `disk-1`,
  });

  console.log(`Disk disk-1 detached from instance ${instance.name}.`);
}
```

**12. Create a Machine Image**

```js
const compute = require('@google-cloud/compute');

async function createImage() {
  await compute.createImage({
    project: 'PROJECT_ID',
    name: 'IMAGE_NAME',
    sourceInstance: 'INSTANCE_NAME',
  });

  console.log(`Image ${'IMAGE_NAME'} created.`);
}
```

**13. Get Machine Image Details**

```js
const compute = require('@google-cloud/compute');

async function getImage() {
  const [image] = await compute.getImage({
    project: 'PROJECT_ID',
    image: 'IMAGE_NAME',
  });

  console.log(`Image ${image.name} details: ${JSON.stringify(image)}`);
}
```

**14. Delete Machine Image**

```js
const compute = require('@google-cloud/compute');

async function deleteImage() {
  await compute.deleteImage({
    project: 'PROJECT_ID',
    image: 'IMAGE_NAME',
  });

  console.log(`Image ${'IMAGE_NAME'} deleted.`);
}
```

**15. Create a Network**

```js
const compute = require('@google-cloud/compute');

async function createNetwork() {
  const [network] = await compute.createNetwork({
    project: 'PROJECT_ID',
    networkResource: {
      name: 'NETWORK_NAME',
      autoCreateSubnetworks: true,
    },
  });

  console.log(`Network ${network.name} created.`);
}
```

**16. Get Network Details**

```js
const compute = require('@google-cloud/compute');

async function getNetwork() {
  const [network] = await compute.getNetwork({
    project: 'PROJECT_ID',
    network: 'NETWORK_NAME',
  });

  console.log(`Network ${network.name} details: ${JSON.stringify(network)}`);
}
```

**17. Delete Network**

```js
const compute = require('@google-cloud/compute');

async function deleteNetwork() {
  await compute.deleteNetwork({
    project: 'PROJECT_ID',
    network: 'NETWORK_NAME',
  });

  console.log(`Network ${'NETWORK_NAME'} deleted.`);
}
```

**18. Create a Firewall Rule**

```js
const compute = require('@google-cloud/compute');

async function createFirewallRule() {
  const [firewallRule] = await compute.createFirewallRule({
    project: 'PROJECT_ID',
    network: 'NETWORK_NAME',
    firewallRuleResource: {
      name: 'FIREWALL_RULE_NAME',
      direction: 'INGRESS',
      allow: ['tcp:80', 'tcp:443'],
      targetTags: ['web'],
      sourceRanges: ['10.0.0.0/24', '10.1.0.0/24'],
    },
  });

  console.log(`Firewall rule ${firewallRule.name} created.`);
}
```

**19. Get Firewall Rule Details**

```js
const compute = require('@google-cloud/compute');

async function getFirewallRule() {
  const [firewallRule] = await compute.getFirewallRule({
    project: 'PROJECT_ID',
    firewallRule: 'FIREWALL_RULE_NAME',
  });

  console.log(`Firewall rule ${firewallRule.name} details: ${JSON.stringify(firewallRule)}`);
}
```

**20. Delete Firewall Rule**

```js
const compute = require('@google-cloud/compute');

async function deleteFirewallRule() {
  await compute.deleteFirewallRule({
    project: 'PROJECT_ID',
    firewallRule: 'FIREWALL_RULE_NAME',
  });

  console.log(`Firewall rule ${'FIREWALL_RULE_NAME'} deleted.`);
}
```

**21. Create a Route**

```js
const compute = require('@google-cloud/compute');

async function createRoute() {
  const [route] = await compute.createRoute({
    project: 'PROJECT_ID',
    network: 'NETWORK_NAME',
    routeResource: {
      name: 'ROUTE_NAME',
      destRange: '10.0.0.0/24',
      nextHopGateway: 'GATEWAY_ADDRESS',
      priority: 1000,
    },
  });

  console.log(`Route ${route.name} created.`);
}
```

**22. Get Route Details**

```js
const compute = require('@google-cloud/compute');

async function getRoute() {
  const [route] = await compute.getRoute({
    project: 'PROJECT_ID',
    route: 'ROUTE_NAME',
  });

  console.log(`Route ${route.name} details: ${JSON.stringify(route)}`);
}
```

**23. Delete Route**

```js
const compute = require('@google-cloud/compute');

async function deleteRoute() {
  await compute.deleteRoute({
    project: 'PROJECT_ID',
    route: 'ROUTE_NAME',
  });

  console.log(`Route ${'ROUTE_NAME'} deleted.`);
}
```

**24. Create a Target Instance**

```js
const compute = require('@google-cloud/compute');

async function createTargetInstance() {
  const [targetInstance] = await compute.createTargetInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    targetInstanceResource: {
      name: 'TARGET_INSTANCE_NAME',
      instance: 'INSTANCE_NAME',
      port: 80,
    },
  });

  console.log(`Target instance ${targetInstance.name} created.`);
}
```

**25. Get Target Instance Details**

```js
const compute = require('@google-cloud/compute');

async function getTargetInstance() {
  const [targetInstance] = await compute.getTargetInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    targetInstance: 'TARGET_INSTANCE_NAME',
  });

  console.log(`Target instance ${targetInstance.name} details: ${JSON.stringify(targetInstance)}`);
}
```

**26. Delete Target Instance**

```js
const compute = require('@google-cloud/compute');

async function deleteTargetInstance() {
  await compute.deleteTargetInstance({
    project: 'PROJECT_ID',
    zone: 'europe-central2-b',
    targetInstance: 'TARGET_INSTANCE_NAME',
  });

  console.log(`Target instance ${'TARGET_INSTANCE_NAME'} deleted.`);
}
```

**27. Create a Target Pool**

```js
const compute = require('@google-cloud/compute');

async function createTargetPool() {
  const [targetPool] = await compute.createTargetPool({
    project: 'PROJECT_ID',
    region: 'europe-central2',
    targetPoolResource: {
      name: 'TARGET_POOL_NAME',
      healthChecks: ['HEALTH_CHECK_NAME'],
      instances: ['targetInstances/TARGET_INSTANCE_NAME'],
    },
  });

  console.log(`Target pool ${targetPool.name} created.`);
}
```

**28. Get Target Pool Details**

```js
const compute = require('@google-cloud/compute');

async function getTargetPool() {
  const [targetPool] = await compute.getTargetPool({
    project: 'PROJECT_ID',
    region: 'europe-central2',
    targetPool: 'TARGET_POOL_NAME',
  });

  console.log(`Target pool ${targetPool.name} details: ${JSON.stringify(targetPool)}`);
}
```

**29. Delete Target Pool**

```js
const compute = require('@google-cloud/compute');

async function deleteTargetPool() {
  await compute.deleteTargetPool({
    project: 'PROJECT_ID',
    region: 'europe-central2',
    targetPool: 'TARGET_POOL_NAME',
  });

  console.log(`Target pool ${'TARGET_POOL_NAME'} deleted.`);
}
```

**30. Create a Health Check**

```js
const compute = require('@google-cloud/compute');

async function createHealthCheck() {
  const [healthCheck] = await compute.createHealthCheck({
    project: 'PROJECT_ID',
    healthCheckResource: {
      name: 'HEALTH_CHECK_NAME',
      type: 'HTTP',
      httpHealthCheck: {
        port: 80,
      },
    },
  });

  console.log(`Health check ${healthCheck.name} created.`);
}
```

**31. Get Health Check Details**

```js
const compute = require('@google-cloud/compute');

async function getHealthCheck() {
  const [healthCheck] = await compute.getHealthCheck({
    project: 'PROJECT_ID',
    healthCheck: 'HEALTH_CHECK_NAME',
  });

  console.log(`Health check ${healthCheck.name} details: ${JSON.stringify(healthCheck)}`);
}
```

**32. Delete Health Check**

```js
const compute = require('@google-cloud/compute');

async function deleteHealthCheck() {
  await compute.deleteHealthCheck({
    project: 'PROJECT_ID',
    healthCheck: 'HEALTH_CHECK_NAME',
  });

  console.log(`Health check ${'HEALTH_CHECK_NAME'} deleted.`);
}
```

**33. Create a Forwarding Rule**

```js
const compute = require('@google-cloud/compute');

async function createForwardingRule() {
  const [firewallRule] = await compute.createForwardingRule({
    project: 'PROJECT_ID',
    region: 'europe-central2',
    forwardingRuleResource: {
      name: 'FORWARDING_RULE_NAME',
      portRange: '80-80',
      target: 'targetPools/TARGET_POOL_NAME',
    },
  });

  console.log(`Forwarding rule ${firewallRule.name} created.`);
}
```

**34. Get Forwarding Rule Details**

```js
const compute = require('@google-cloud/compute');

async function getForwardingRule() {
  const [firewallRule] = await compute.getForwardingRule({
    project: 'PROJECT_ID',
    region: 'europe-central2',
    forwardingRule: 'FORWARDING_RULE_NAME',
  });

  console.log(`Forwarding rule ${firewallRule.name} details: ${JSON.stringify(firewallRule)}`);
}
```

**35. Delete Forwarding Rule**

```js
const compute = require('@google-cloud/compute');

async function deleteForwardingRule() {
  await compute.deleteForwardingRule({
    project: 'PROJECT_ID',
    region: 'europe-central2',
    forwardingRule: 'FORWARDING_RULE_NAME',
  });

  console.log(`Forwarding rule ${'FORWARDING_RULE_NAME'} deleted.`);
}
```

**36. Get List of Operations**

```js
const compute = require('@google-cloud/compute');

async function listOperations() {
  const [operations] = await compute.getOperations({
    project: 'PROJECT_ID',
  });

  console.log('Operations:');
  operations.forEach(operation => {
    console.log(`- ${operation.name}: ${operation.operationType}`);
  });
}
```