Compute Engine bietet vordefinierte Maschinentypen, die Sie beim Erstellen einer VM-Instanz verwenden können. Ein vordefinierter Maschinentyp hat eine voreingestellte Anzahl von vCPUs und eine vorgegebene Speichergröße und wird zu einem festen Preis abgerechnet.
Wenn vordefinierte VMs Ihren Anforderungen nicht entsprechen, können Sie eine VM-Instanz mit benutzerdefinierten virtualisierten Hardwareeinstellungen erstellen. Sie können eine VM-Instanz mit einer benutzerdefinierten Anzahl von vCPUs und einer benutzerdefinierten Speichergröße erzeugen, wodurch Sie praktisch einen benutzerdefinierten Maschinentyp verwenden. Mit benutzerdefinierten Maschinentypen können Sie VM-Instanzen mit nur 1 vCPU und einer beliebigen geraden Anzahl von vCPUs (maximal 96) erstellen. Pro vCPU sind bis zu 8 GB Speicher möglich.
Benutzerdefinierte Maschinentypen sind in der Maschinenfamilie für allgemeine Zwecke verfügbar.
Wenn Sie eine benutzerdefinierte VM erstellen, stellen Sie eine benutzerdefinierte VM aus der Maschinenfamilie E2, N2, N2D oder N1 bereit.
Benutzerdefinierte VMs sind in folgenden Szenarien ideal:
- Arbeitslasten, die mit den vordefinierten virtuellen Maschinentypen nicht bewältigt werden können.
- Arbeitslasten, die mehr Verarbeitungsleistung oder mehr Speicher erfordern, aber nicht alle Upgrades benötigen, die der nächstgrößere vordefinierte Maschinentyp bietet.
Hinweise
Erforderliche Rollen
Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle (roles/compute.instanceAdmin.v1) Compute-Instanzadministrator (v1) für das Projekt zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Erstellen einer VM mit einem benutzerdefinierten Maschinentyp benötigen.
Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.
Diese vordefinierte Rolle enthält die Berechtigungen, die zum Erstellen einer VM mit einem benutzerdefinierten Maschinentyp erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:
Erforderliche Berechtigungen
Die folgenden Berechtigungen sind erforderlich, um eine VM mit einem benutzerdefinierten Maschinentyp zu erstellen:
-
So fügen Sie einer vorhandenen VM erweiterten Speicher hinzu:
compute.instances.setMachineType auf der VM
-
VM mit benutzerdefiniertem Maschinentyp erstellen:
compute.instances.create für das Projekt- So erstellen Sie die VM mit einem benutzerdefinierten Image:
compute.images.useReadOnly für das Image - So erstellen Sie die VM mit einem Snapshot:
compute.snapshots.useReadOnly für den Snapshot - So verwenden Sie eine Instanzvorlage zum Erstellen der VM:
compute.instanceTemplates.useReadOnly für die Instanzvorlage - So weisen Sie der VM ein Legacy-Netzwerk zu:
compute.networks.use für das Projekt - So geben Sie eine statische IP-Adresse für die VM an:
compute.addresses.use für das Projekt - So weisen Sie der VM eine externe IP-Adresse zu, wenn Sie ein Legacy-Netzwerk verwenden:
compute.networks.useExternalIp für das Projekt - So geben Sie ein Subnetz für die VM an:
compute.subnetworks.use für das Projekt oder für das ausgewählte Subnetz - So weisen Sie der VM eine externe IP-Adresse zu, wenn Sie ein VPC-Netzwerk verwenden:
compute.subnetworks.useExternalIp für das Projekt oder für das ausgewählte Subnetz - So legen Sie die VM-Instanzmetadaten für die VM fest:
compute.instances.setMetadata für das Projekt - Zum Festlegen von Tags für die VM:
compute.instances.setTags auf der VM - So legen Sie Labels für die VM fest:
compute.instances.setLabels auf der VM - So legen Sie ein Dienstkonto fest, das von der VM verwendet werden soll:
compute.instances.setServiceAccount auf der VM - So erstellen Sie ein neues Laufwerk für die VM:
compute.disks.create für das Projekt - So hängen Sie ein vorhandenes Laufwerk im Lese- oder Lesemodus an:
compute.disks.use für das Laufwerk - So fügen Sie ein vorhandenes Laufwerk im Lesemodus hinzu:
compute.disks.useReadOnly für das Laufwerk
Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.
Preise
Die von Google für benutzerdefinierte VMs berechneten Gebühren hängen von der Anzahl der vCPUs und den Speicherstunden ab, die die VM nutzt. Dies unterscheidet sich von der Gebührenberechnung für vordefinierte Maschinentypen. Die On-Demand-Preise für benutzerdefinierte Maschinentypen enthalten einen Aufschlag von 5 % auf die On-Demand-Preise für Standardmaschinentypen.
Preisinformationen zu benutzerdefinierten Maschinentypen aus jeder Maschinenfamilie finden Sie unter Preise für VM-Instanzen.
Benutzerdefinierte VMs unterliegen derselben 1-Minuten-Mindestgebühr, aber die Rabatte für kontinuierliche Nutzung werden für benutzerdefinierte Maschinentypen anders berechnet. Weitere Informationen finden Sie unter Rabatte für kontinuierliche Nutzung für benutzerdefinierte VMs.
Speicherdarstellung in GB oder MB
Für Tools und Dokumentation der Google Cloud wird der Maschinentypspeicher in Gigabyte (GB) berechnet, wobei 1 GB gleich 230 Byte ist. Diese Maßeinheit wird auch als Gibibyte (GiB) bezeichnet.
Bei der Speicherumrechnung von GB in MB gilt: 1 GB = 1.024 MB.
In der API müssen Sie Speicher immer in Megabyte angeben. Wenn Sie das Google Cloud CLI verwenden, können Sie den Gesamtspeicher für eine VM in Gigabyte oder Megabyte angeben. Die gcloud CLI erwartet beim Speicher jedoch einen ganzzahligen Wert, Sie können also keine Fließkommazahl angeben. Wenn Sie beispielsweise 5,75 GB angeben wollen, konvertieren Sie 5,75 GB stattdessen in MB. In diesem Fall sind 5,75 GB gleich 5.888 MB.
VM mit benutzerdefiniertem Maschinentyp erstellen
Bevor Sie eine VM-Instanz erstellen, müssen Sie die
benutzerdefinierten Spezifikationen für die Erstellung dieses Maschinentyps gelesen und verstanden haben.
Console
Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.
Zur Seite „Instanz erstellen“
Wählen Sie in der Liste Zone die Zone aus, in der diese VM gehostet werden soll.
Die Liste Reihe wird so gefiltert, dass nur die in der ausgewählten Zone verfügbaren Maschinentypenfamilien enthalten sind.
Wählen Sie im Abschnitt Maschinenkonfiguration die Option Allgemeiner Zweck aus.
- Klicken Sie in der Liste Reihe auf N1 als Erste Generation für benutzerdefinierte N1-Maschinentypen oder E2, N2, oder N2D als Zweite Generation für benutzerdefinierte Maschinentypen.
- Wählen Sie im Abschnitt Maschinentyp die Option Benutzerdefiniert aus.
- Betätigen Sie die Schieberegler oder geben Sie die Werte in die Textfelder ein, um die Anzahl der vCPUs und den Speicherplatz für die VM-Instanz anzugeben. In der Console wird eine Kostenschätzung für die Instanz angezeigt, wenn Sie die Anzahl der vCPUs und die Speichermenge ändern.
Fahren Sie mit dem Erstellen der VM fort.
gcloud
Der Befehl gcloud für benutzerdefinierte Maschinentypen kann abhängig von der Maschinentypfamilie geringfügig variieren.
Für N1-Maschinentypen verwenden Sie den Befehl gcloud compute instances create und fügen eine der folgenden Optionen hinzu:
- Die Flags
--custom-cpu und --custom-memory.
- Das Flag
--machine-type=custom-[NUMBER_OF_CPUS]-[NUMBER_OF_MB].
Der folgende Befehl erstellt beispielsweise eine Instanz, auf der ein N1-Maschinentyp mit 4 vCPUs und 5 GB Gesamtspeicher ausgeführt wird:
gcloud compute instances create example-instance \
--custom-cpu=4 --custom-memory=5
Für N2-Maschinentypen verwenden Sie den Befehl gcloud compute instances create und fügen eine der folgenden Optionen hinzu:
- Die Flags
--custom-cpu, --custom-memory und --custom-vm-type.
- Das Flag
--machine-type=n2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB.
Wenn Sie das Flag --custom-memory verwenden, müssen Sie die Gesamtgröße des Arbeitsspeichers in GB oder in MB angeben. Das Attribut muss eine Ganzzahl sein, d. h., wenn Sie den Speicher in Schritten von 0,25 GB festlegen möchten, müssen Sie diesen Wert in MB umwandeln.
Für die Angabe eines inkrementellen Werts wie 2,5 GB Speicher rechnen Sie den Wert in MB um und geben ihn mit dem Suffix MB an: Das folgende Beispiel erstellt eine Instanz, auf der ein N2-Maschinentyp ausgeführt wird:
gcloud compute instances create example-instance \
--custom-cpu=6 --custom-memory=3072MB --custom-vm-type=n2
Alternativ können Sie einen benutzerdefinierten Maschinentyp mit folgendem Format festlegen:
gcloud compute instances create example-instance \
--machine-type n2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
Ersetzen Sie Folgendes:
NUMBER_OF_CPUS: Die gewünschte Anzahl der CPUs.NUMBER_OF_MB: Die Größe des Arbeitsspeichers in MB.
Beispiel:
gcloud compute instances create example-instance --machine-type=n2-custom-6-3072
Für N2D- oder E2-Maschinentypen verwenden Sie den Befehl gcloud compute instances create und fügen eine der folgenden Optionen hinzu:
- Die Flags
--custom-cpu, --custom-memory und --custom-vm-type.
- Das Flag
--machine-type=n2d-custom-NUMBER_OF_CPUS-NUMBER_OF_MB.
- Das Flag
--machine-type=e2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB.
Verwenden Sie für benutzerdefinierte E2-Maschinentypen mit gemeinsame genutztem Kern den gleichen Befehl gcloud compute instances create und fügen Sie die Maschinengröße mit gemeinsam genutztem Kern ein: micro, small oder medium
- Das Flag
--machine-type=e2-custom-SHARED_CORE_MACHINE_SIZE-NUMBER_OF_MB.
Beispiel:
gcloud compute instances create example-instance \
--machine-type=e2-custom-medium-NUMBER_OF_MB
Wenn Sie das Flag --custom-memory verwenden, müssen Sie die Gesamtgröße des Arbeitsspeichers in GB oder in MB angeben. Das Attribut muss eine Ganzzahl sein. Wenn Sie den Arbeitsspeicher also in Schritten von 0,25 GB festlegen möchten, müssen Sie den Wert in MB umwandeln.
Für die Angabe eines inkrementellen Werts wie 2,5 GB Speicher rechnen Sie den Wert in MB um und geben ihn mit dem Suffix MB an: Das folgende Beispiel erstellt eine Instanz, auf der ein E2-Maschinentyp ausgeführt wird:
gcloud compute instances create example-instance \
--custom-cpu=6 --custom-memory=3072MB --custom-vm-type=e2
Alternativ können Sie einen benutzerdefinierten Maschinentyp mit folgendem Format festlegen:
gcloud compute instances create example-instance \
--machine-type=e2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
Ersetzen Sie Folgendes:
NUMBER_OF_CPUS: Die gewünschte Anzahl der CPUs.NUMBER_OF_MB: Die Größe des Arbeitsspeichers in MB.
Beispiel:
gcloud compute instances create example-instance --machine-type=e2-custom-6-3072
Zum Generieren des Terraform-Codes können Sie die Komponente Entsprechender Code in der Google Cloud Console verwenden.
- Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.
Zu Seite „VM-Instanzen“
- Klicken Sie auf Instanz erstellen.
- Geben Sie die gewünschten Parameter an.
- Klicken Sie oben oder unten auf der Seite auf Entsprechender Code und dann auf den Tab Terraform, um den Terraform-Code aufzurufen.
Einfach loslegen (Go)
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
import (
"context"
"fmt"
"io"
compute "cloud.google.com/go/compute/apiv1"
computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
"google.golang.org/protobuf/proto"
)
func customMachineTypeURI(zone, cpuSeries string, coreCount, memory int) (string, error) {
const (
n1 = "custom"
n2 = "n2-custom"
n2d = "n2d-custom"
e2 = "e2-custom"
e2Micro = "e2-custom-micro"
e2Small = "e2-custom-small"
e2Medium = "e2-custom-medium"
)
type typeLimit struct {
allowedCores []int
minMemPerCore int
maxMemPerCore int
allowExtraMemory bool
extraMemoryLimit int
}
makeRange := func(start, end, step int) []int {
if step <= 0 || end < start {
return []int{}
}
s := make([]int, 0, 1+(end-start)/step)
for start <= end {
s = append(s, start)
start += step
}
return s
}
containsString := func(s []string, str string) bool {
for _, v := range s {
if v == str {
return true
}
}
return false
}
containsInt := func(nums []int, n int) bool {
for _, v := range nums {
if v == n {
return true
}
}
return false
}
var (
cpuSeriesE2Limit = typeLimit{
allowedCores: makeRange(2, 33, 2),
minMemPerCore: 512,
maxMemPerCore: 8192,
}
cpuSeriesE2MicroLimit = typeLimit{minMemPerCore: 1024, maxMemPerCore: 2048}
cpuSeriesE2SmallLimit = typeLimit{minMemPerCore: 2048, maxMemPerCore: 4096}
cpuSeriesE2MeidumLimit = typeLimit{minMemPerCore: 4096, maxMemPerCore: 8192}
cpuSeriesN2Limit = typeLimit{
allowedCores: append(makeRange(2, 33, 2), makeRange(36, 129, 4)...),
minMemPerCore: 512, maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
}
cpuSeriesN2DLimit = typeLimit{
allowedCores: []int{2, 4, 8, 16, 32, 48, 64, 80, 96},
minMemPerCore: 512, maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 768 << 10,
}
cpuSeriesN1Limit = typeLimit{
allowedCores: append([]int{1}, makeRange(2, 97, 2)...),
minMemPerCore: 922,
maxMemPerCore: 6656,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
}
)
typeLimitsMap := map[string]typeLimit{
n1: cpuSeriesN1Limit,
n2: cpuSeriesN2Limit,
n2d: cpuSeriesN2DLimit,
e2: cpuSeriesE2Limit,
e2Micro: cpuSeriesE2MicroLimit,
e2Small: cpuSeriesE2SmallLimit,
e2Medium: cpuSeriesE2MeidumLimit,
}
if !containsString([]string{e2, n1, n2, n2d}, cpuSeries) {
return "", fmt.Errorf("incorrect cpu type: %v", cpuSeries)
}
tl := typeLimitsMap[cpuSeries]
// Check whether the requested parameters are allowed.
// Find more information about limitations of custom machine types at:
// https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
// Check the number of cores
if len(tl.allowedCores) > 0 && !containsInt(tl.allowedCores, coreCount) {
return "", fmt.Errorf(
"invalid number of cores requested. Allowed number of cores for %v is: %v",
cpuSeries,
tl.allowedCores,
)
}
// Memory must be a multiple of 256 MB
if memory%256 != 0 {
return "", fmt.Errorf("requested memory must be a multiple of 256 MB")
}
// Check if the requested memory isn't too little
if memory < coreCount*tl.minMemPerCore {
return "", fmt.Errorf(
"requested memory is too low. Minimal memory for %v is %v MB per core",
cpuSeries,
tl.minMemPerCore,
)
}
// Check if the requested memory isn't too much
if memory > coreCount*tl.maxMemPerCore && !tl.allowExtraMemory {
return "", fmt.Errorf(
"requested memory is too large.. Maximum memory allowed for %v is %v MB per core",
cpuSeries,
tl.maxMemPerCore,
)
}
if memory > tl.extraMemoryLimit && tl.allowExtraMemory {
return "", fmt.Errorf(
"requested memory is too large.. Maximum memory allowed for %v is %v MB",
cpuSeries,
tl.extraMemoryLimit,
)
}
// Return the custom machine type in form of a string acceptable by Compute Engine API.
if containsString([]string{e2Small, e2Micro, e2Medium}, cpuSeries) {
return fmt.Sprintf("zones/%v/machineTypes/%v-%v", zone, cpuSeries, memory), nil
}
if memory > coreCount*tl.maxMemPerCore {
return fmt.Sprintf(
"zones/%v/machineTypes/%v-%v-%v-ext",
zone,
cpuSeries,
coreCount,
memory,
), nil
}
return fmt.Sprintf("zones/%v/machineTypes/%v-%v-%v", zone, cpuSeries, coreCount, memory), nil
}
// createInstanceWithCustomMachineTypeWithHelper creates a new VM instance with a custom machine type.
func createInstanceWithCustomMachineTypeWithHelper(
w io.Writer,
projectID, zone, instanceName, cpuSeries string,
coreCount, memory int,
) error {
// projectID := "your_project_id"
// zone := "europe-central2-b"
// instanceName := "your_instance_name"
// cpuSeries := "e2-custom-micro" // the type of CPU you want to use"
// coreCount := 2 // number of CPU cores you want to use.
// memory := 256 // the amount of memory for the VM instance, in megabytes.
machineType, err := customMachineTypeURI(zone, cpuSeries, coreCount, memory)
if err != nil {
return fmt.Errorf("unable to create custom machine type string: %w", err)
}
ctx := context.Background()
instancesClient, err := compute.NewInstancesRESTClient(ctx)
if err != nil {
return fmt.Errorf("NewInstancesRESTClient: %w", err)
}
defer instancesClient.Close()
req := &computepb.InsertInstanceRequest{
Project: projectID,
Zone: zone,
InstanceResource: &computepb.Instance{
Name: proto.String(instanceName),
Disks: []*computepb.AttachedDisk{
{
InitializeParams: &computepb.AttachedDiskInitializeParams{
DiskSizeGb: proto.Int64(10),
SourceImage: proto.String(
"projects/debian-cloud/global/images/family/debian-10",
),
},
AutoDelete: proto.Bool(true),
Boot: proto.Bool(true),
},
},
MachineType: proto.String(machineType),
NetworkInterfaces: []*computepb.NetworkInterface{
{
Name: proto.String("global/networks/default"),
},
},
},
}
op, err := instancesClient.Insert(ctx, req)
if err != nil {
return fmt.Errorf("unable to create instance: %w", err)
}
if err = op.Wait(ctx); err != nil {
return fmt.Errorf("unable to wait for the operation: %w", err)
}
fmt.Fprintf(w, "Instance created\n")
return nil
}
Java
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.IntStream;
public class CreateWithHelper {
// This class defines the configurable parameters for a custom VM.
static final class TypeLimits {
int[] allowedCores;
int minMemPerCore;
int maxMemPerCore;
int extraMemoryLimit;
boolean allowExtraMemory;
TypeLimits(int[] allowedCores, int minMemPerCore, int maxMemPerCore, boolean allowExtraMemory,
int extraMemoryLimit) {
this.allowedCores = allowedCores;
this.minMemPerCore = minMemPerCore;
this.maxMemPerCore = maxMemPerCore;
this.allowExtraMemory = allowExtraMemory;
this.extraMemoryLimit = extraMemoryLimit;
}
}
public enum CpuSeries {
N1("custom"),
N2("n2-custom"),
N2D("n2d-custom"),
E2("e2-custom"),
E2_MICRO("e2-custom-micro"),
E2_SMALL("e2-custom-small"),
E2_MEDIUM("e2-custom-medium");
private static final Map<String, CpuSeries> ENUM_MAP;
static {
ENUM_MAP = init();
}
// Build an immutable map of String name to enum pairs.
public static Map<String, CpuSeries> init() {
Map<String, CpuSeries> map = new ConcurrentHashMap<>();
for (CpuSeries instance : CpuSeries.values()) {
map.put(instance.getCpuSeries(), instance);
}
return Collections.unmodifiableMap(map);
}
private final String cpuSeries;
CpuSeries(String cpuSeries) {
this.cpuSeries = cpuSeries;
}
public static CpuSeries get(String name) {
return ENUM_MAP.get(name);
}
public String getCpuSeries() {
return this.cpuSeries;
}
}
// This enum correlates a machine type with its limits.
// The limits for various CPU types are described in:
// https://cloud.google.com/compute/docs/general-purpose-machines
enum Limits {
CPUSeries_E2(new TypeLimits(getNumsInRangeWithStep(2, 33, 2), 512, 8192, false, 0)),
CPUSeries_E2MICRO(new TypeLimits(new int[]{}, 1024, 2048, false, 0)),
CPUSeries_E2SMALL(new TypeLimits(new int[]{}, 2048, 4096, false, 0)),
CPUSeries_E2MEDIUM(new TypeLimits(new int[]{}, 4096, 8192, false, 0)),
CPUSeries_N2(
new TypeLimits(concat(getNumsInRangeWithStep(2, 33, 2), getNumsInRangeWithStep(36, 129, 4)),
512, 8192, true, gbToMb(624))),
CPUSeries_N2D(
new TypeLimits(new int[]{2, 4, 8, 16, 32, 48, 64, 80, 96}, 512, 8192, true, gbToMb(768))),
CPUSeries_N1(
new TypeLimits(concat(new int[]{1}, getNumsInRangeWithStep(2, 97, 2)), 922, 6656, true,
gbToMb(624)));
private final TypeLimits typeLimits;
Limits(TypeLimits typeLimits) {
this.typeLimits = typeLimits;
}
public TypeLimits getTypeLimits() {
return typeLimits;
}
}
static ImmutableMap<String, Limits> typeLimitsMap = ImmutableMap.<String, Limits>builder()
.put("N1", Limits.CPUSeries_N1)
.put("N2", Limits.CPUSeries_N2)
.put("N2D", Limits.CPUSeries_N2D)
.put("E2", Limits.CPUSeries_E2)
.put("E2_MICRO", Limits.CPUSeries_E2MICRO)
.put("E2_SMALL", Limits.CPUSeries_E2SMALL)
.put("E2_MEDIUM", Limits.CPUSeries_E2SMALL)
.build();
// Returns the array of integers within the given range, incremented by the specified step.
// start (inclusive): starting number of the range
// stop (inclusive): ending number of the range
// step : increment value
static int[] getNumsInRangeWithStep(int start, int stop, int step) {
return IntStream.range(start, stop).filter(x -> (x - start) % step == 0).toArray();
}
static int gbToMb(int value) {
return value << 10;
}
static int[] concat(int[] a, int[] b) {
int[] result = new int[a.length + b.length];
System.arraycopy(a, 0, result, 0, a.length);
System.arraycopy(b, 0, result, a.length, b.length);
return result;
}
public static void main(String[] args)
throws IOException, ExecutionException, InterruptedException, TimeoutException {
// TODO(developer): Replace these variables before running the sample.
// Project ID or project number of the Cloud project you want to use.
String projectId = "your-google-cloud-project-id";
// Name of the zone to create the instance in. For example: "us-west3-b".
String zone = "google-cloud-zone";
// Name of the new virtual machine (VM) instance.
String instanceName = "instance-name";
String cpuSeries = "N1";
// Number of CPU cores you want to use.
int coreCount = 2;
// The amount of memory for the VM instance, in megabytes.
int memory = 256;
createInstanceWithCustomMachineTypeWithHelper(
projectId, zone, instanceName, cpuSeries, coreCount, memory);
}
// Create a VM instance with a custom machine type.
public static void createInstanceWithCustomMachineTypeWithHelper(
String project, String zone, String instanceName, String cpuSeries, int coreCount, int memory)
throws IOException, ExecutionException, InterruptedException, TimeoutException {
// Construct the URI string identifying the machine type.
String machineTypeUri = customMachineTypeUri(zone, cpuSeries, coreCount, memory);
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the `instancesClient.close()` method on the client to safely
// clean up any remaining background resources.
try (InstancesClient instancesClient = InstancesClient.create()) {
AttachedDisk attachedDisk = AttachedDisk.newBuilder()
.setInitializeParams(
// Describe the size and source image of the boot disk to attach to the instance.
// The list of public images available in Compute Engine can be found here:
// https://cloud.google.com/compute/docs/images#list_of_public_images_available_on
AttachedDiskInitializeParams.newBuilder()
.setSourceImage(
String.format("projects/%s/global/images/family/%s", "debian-cloud",
"debian-11"))
.setDiskSizeGb(10)
.build()
)
// Remember to set auto_delete to True if you want the disk to be deleted when you delete
// your VM instance.
.setAutoDelete(true)
.setBoot(true)
.build();
// Create the Instance object with the relevant information.
Instance instance = Instance.newBuilder()
.setName(instanceName)
.addDisks(attachedDisk)
.setMachineType(machineTypeUri)
.addNetworkInterfaces(
NetworkInterface.newBuilder().setName("global/networks/default").build())
.build();
// Create the insert instance request object.
InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
.setProject(project)
.setZone(zone)
.setInstanceResource(instance)
.build();
// Invoke the API with the request object and wait for the operation to complete.
Operation response = instancesClient.insertAsync(insertInstanceRequest)
.get(3, TimeUnit.MINUTES);
// Check for errors.
if (response.hasError()) {
throw new Error("Instance creation failed!!" + response);
}
System.out.printf("Instance created : %s", instanceName);
System.out.println("Operation Status: " + response.getStatus());
}
}
public static String customMachineTypeUri(String zone, String cpuSeries, int coreCount,
int memory) {
if (!Arrays.asList(CpuSeries.E2.cpuSeries, CpuSeries.N1.cpuSeries, CpuSeries.N2.cpuSeries,
CpuSeries.N2D.cpuSeries).contains(cpuSeries)) {
throw new Error(String.format("Incorrect cpu type: %s", cpuSeries));
}
TypeLimits typeLimit = Objects.requireNonNull(
typeLimitsMap.get(CpuSeries.get(cpuSeries).name())).typeLimits;
// Perform the following checks to verify if the requested parameters are allowed.
// Find more information about limitations of custom machine types at:
// https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
// 1. Check the number of cores and if the coreCount is present in allowedCores.
if (typeLimit.allowedCores.length > 0 && Arrays.stream(typeLimit.allowedCores)
.noneMatch(x -> x == coreCount)) {
throw new Error(String.format(
"Invalid number of cores requested. "
+ "Number of cores requested for CPU %s should be one of: %s",
cpuSeries,
Arrays.toString(typeLimit.allowedCores)));
}
// 2. Memory must be a multiple of 256 MB
if (memory % 256 != 0) {
throw new Error("Requested memory must be a multiple of 256 MB");
}
// 3. Check if the requested memory isn't too little
if (memory < coreCount * typeLimit.minMemPerCore) {
throw new Error(
String.format("Requested memory is too low. Minimum memory for %s is %s MB per core",
cpuSeries, typeLimit.minMemPerCore));
}
// 4. Check if the requested memory isn't too much
if (memory > coreCount * typeLimit.maxMemPerCore && !typeLimit.allowExtraMemory) {
throw new Error(String.format(
"Requested memory is too large.. Maximum memory allowed for %s is %s MB per core",
cpuSeries, typeLimit.extraMemoryLimit));
}
// 5. Check if the requested memory isn't too large
if (memory > typeLimit.extraMemoryLimit && typeLimit.allowExtraMemory) {
throw new Error(
String.format("Requested memory is too large.. Maximum memory allowed for %s is %s MB",
cpuSeries, typeLimit.extraMemoryLimit));
}
// Check if the CPU Series is E2 and return the custom machine type in the form of a string
// acceptable by Compute Engine API.
if (Arrays.asList(CpuSeries.E2_SMALL.cpuSeries, CpuSeries.E2_MICRO.cpuSeries,
CpuSeries.E2_MEDIUM.cpuSeries).contains(cpuSeries)) {
return String.format("zones/%s/machineTypes/%s-%s", zone, cpuSeries, memory);
}
// Check if extended memory was requested and return the extended custom machine type
// in the form of a string acceptable by Compute Engine API.
if (memory > coreCount * typeLimit.maxMemPerCore) {
return String.format("zones/%s/machineTypes/%s-%s-%s-ext", zone, cpuSeries, coreCount,
memory);
}
// Return the custom machine type in the form of a standard string
// acceptable by Compute Engine API.
return String.format("zones/%s/machineTypes/%s-%s-%s", zone, cpuSeries, coreCount, memory);
}
}
Node.js
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Node.js API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
/**
* TODO(developer): Uncomment and replace these variables before running the sample.
*/
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const cpuSeries = 'N1';
// const coreCount = 2
// const memory = 256
const compute = require('@google-cloud/compute');
function range(from, to, step) {
return [...Array(Math.floor((to - from) / step) + 1)].map(
(_, i) => from + i * step
);
}
class CustomMachineType {
constructor(zone, cpuSeries, coreCount, memory) {
this.zone = zone;
this.cpuSeries = cpuSeries;
this.coreCount = coreCount;
this.memory = memory;
this.N1 = 'custom';
this.N2 = 'n2-custom';
this.N2D = 'n2d-custom';
this.E2 = 'e2-custom';
this.E2Micro = 'e2-custom-micro';
this.E2Small = 'e2-custom-small';
this.E2Medium = 'e2-custom-medium';
this.CpuSeriesE2Limit = {
allowedCores: range(2, 33, 2),
minMemPerCore: 512,
maxMemPerCore: 8192,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesE2MicroLimit = {
allowedCores: [],
minMemPerCore: 1024,
maxMemPerCore: 2048,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesE2SmallLimit = {
allowedCores: [],
minMemPerCore: 2048,
maxMemPerCore: 4096,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesE2MediumLimit = {
allowedCores: [],
minMemPerCore: 4096,
maxMemPerCore: 8192,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesN2Limit = {
allowedCores: [...range(2, 33, 2), ...range(36, 129, 4)],
minMemPerCore: 512,
maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
};
this.CpuSeriesN2DLimit = {
allowedCores: [2, 4, 8, 16, 32, 48, 64, 80, 96],
minMemPerCore: 512,
maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 768 << 10,
};
this.CpuSeriesN1Limit = {
allowedCores: [1, range(2, 97, 2)],
minMemPerCore: 922,
maxMemPerCore: 6656,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
};
this.TYPE_LIMITS = {
[this.N1]: this.CpuSeriesN1Limit,
[this.N2]: this.CpuSeriesN2Limit,
[this.N2D]: this.CpuSeriesN2DLimit,
[this.E2]: this.CpuSeriesE2Limit,
[this.E2Micro]: this.CpuSeriesE2MicroLimit,
[this.E2Small]: this.CpuSeriesE2SmallLimit,
[this.E2Medium]: this.CpuSeriesE2MediumLimit,
};
if (![this.E2, this.N1, this.N2, this.N2D].includes(cpuSeries)) {
throw new Error(`Incorrect CPU type: ${this.cpuSeries}`);
}
this.typeLimit = this.TYPE_LIMITS[this.cpuSeries];
// Check whether the requested parameters are allowed.
// Find more information about limitations of custom machine types at:
// https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
// Check the number of cores
if (
this.typeLimit.allowedCores.length > 0 &&
!this.typeLimit.allowedCores.includes(coreCount)
) {
throw new Error(
`Invalid number of cores requested. Allowed number of cores for ${this.cpuSeries} is: ${this.typeLimit.allowedCores}`
);
}
// Memory must be a multiple of 256 MB
if (this.memory % 256 !== 0) {
throw new Error('Requested memory must be a multiple of 256 MB');
}
// Check if the requested memory isn't too little
if (this.memory < this.coreCount * this.typeLimit.minMemPerCore) {
throw new Error(
`Requested memory is too low. Minimal memory for ${this.cpuSeries} is ${this.typeLimit.minMemPerCore} MB per core`
);
}
// Check if the requested memory isn't too much
if (
this.memory > this.coreCount * this.typeLimit.maxMemPerCore &&
!this.typeLimit.allowExtraMemory
) {
throw new Error(
`Requested memory is too large.. Maximum memory allowed for ${this.cpuSeries} is ${this.typeLimit.maxMemPerCore} MB per core`
);
}
if (
this.memory > this.typeLimit.extraMemoryLimit &&
this.typeLimit.allowExtraMemory
) {
throw new Error(
`Requested memory is too large.. Maximum memory allowed for ${this.cpuSeries} is ${this.typeLimit.extraMemoryLimit} MB`
);
}
}
// Returns the custom machine type in form of a string acceptable by Compute Engine API.
getMachineTypeURI() {
if (
[this.E2Small, this.E2Micro, this.E2Medium].includes(this.cpuSeries)
) {
return `zones/${this.zone}/machineTypes/${this.cpuSeries}-${this.memory}`;
}
if (this.memory > this.coreCount * this.typeLimit.maxMemPerCore) {
return `zones/${this.zone}/machineTypes/${this.cpuSeries}-${this.coreCount}-${this.memory}-ext`;
}
return `zones/${zone}/machineTypes/${this.cpuSeries}-${this.coreCount}-${this.memory}`;
}
}
async function createInstanceWithCustomMachineTypeWithHelper() {
const instancesClient = new compute.InstancesClient();
const machineType = new CustomMachineType(
zone,
cpuSeries,
coreCount,
memory
).getMachineTypeURI();
const [response] = await instancesClient.insert({
instanceResource: {
name: instanceName,
disks: [
{
initializeParams: {
diskSizeGb: '64',
sourceImage:
'projects/debian-cloud/global/images/family/debian-11/',
},
autoDelete: true,
boot: true,
},
],
machineType,
networkInterfaces: [
{
name: 'global/networks/default',
},
],
},
project: projectId,
zone,
});
let operation = response.latestResponse;
const operationsClient = new compute.ZoneOperationsClient();
// Wait for the create operation to complete.
while (operation.status !== 'DONE') {
[operation] = await operationsClient.wait({
operation: operation.name,
project: projectId,
zone: operation.zone.split('/').pop(),
});
}
console.log('Instance created.');
}
createInstanceWithCustomMachineTypeWithHelper();
Python
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
from __future__ import annotations
from collections import namedtuple
from enum import Enum
from enum import unique
import re
import sys
from typing import Any
import warnings
from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1
def gb_to_mb(value: int) -> int:
return value << 10
class CustomMachineType:
"""
Allows to create custom machine types to be used with the VM instances.
"""
@unique
class CPUSeries(Enum):
N1 = "custom"
N2 = "n2-custom"
N2D = "n2d-custom"
E2 = "e2-custom"
E2_MICRO = "e2-custom-micro"
E2_SMALL = "e2-custom-small"
E2_MEDIUM = "e2-custom-medium"
TypeLimits = namedtuple(
"TypeLimits",
[
"allowed_cores",
"min_mem_per_core",
"max_mem_per_core",
"allow_extra_memory",
"extra_memory_limit",
],
)
# The limits for various CPU types are described on:
# https://cloud.google.com/compute/docs/general-purpose-machines
LIMITS = {
CPUSeries.E2: TypeLimits(frozenset(range(2, 33, 2)), 512, 8192, False, 0),
CPUSeries.E2_MICRO: TypeLimits(frozenset(), 1024, 2048, False, 0),
CPUSeries.E2_SMALL: TypeLimits(frozenset(), 2048, 4096, False, 0),
CPUSeries.E2_MEDIUM: TypeLimits(frozenset(), 4096, 8192, False, 0),
CPUSeries.N2: TypeLimits(
frozenset(range(2, 33, 2)).union(set(range(36, 129, 4))),
512,
8192,
True,
gb_to_mb(624),
),
CPUSeries.N2D: TypeLimits(
frozenset({2, 4, 8, 16, 32, 48, 64, 80, 96}), 512, 8192, True, gb_to_mb(768)
),
CPUSeries.N1: TypeLimits(
frozenset({1}.union(range(2, 97, 2))), 922, 6656, True, gb_to_mb(624)
),
}
def __init__(
self, zone: str, cpu_series: CPUSeries, memory_mb: int, core_count: int = 0
):
self.zone = zone
self.cpu_series = cpu_series
self.limits = self.LIMITS[self.cpu_series]
# Shared machine types (e2-small, e2-medium and e2-micro) always have
# 2 vCPUs: https://cloud.google.com/compute/docs/general-purpose-machines#e2_limitations
self.core_count = 2 if self.is_shared() else core_count
self.memory_mb = memory_mb
self._checked = False
self._check_parameters()
self.extra_memory_used = self._check_extra_memory()
def is_shared(self):
return self.cpu_series in (
CustomMachineType.CPUSeries.E2_SMALL,
CustomMachineType.CPUSeries.E2_MICRO,
CustomMachineType.CPUSeries.E2_MEDIUM,
)
def _check_extra_memory(self) -> bool:
if self._checked:
return self.memory_mb > self.core_count * self.limits.max_mem_per_core
else:
raise RuntimeError(
"You need to call _check_parameters() before calling _check_extra_memory()"
)
def _check_parameters(self):
"""
Check whether the requested parameters are allowed. Find more information about limitations of custom machine
types at: https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
"""
# Check the number of cores
if (
self.limits.allowed_cores
and self.core_count not in self.limits.allowed_cores
):
raise RuntimeError(
f"Invalid number of cores requested. Allowed number of cores for {self.cpu_series.name} is: {sorted(self.limits.allowed_cores)}"
)
# Memory must be a multiple of 256 MB
if self.memory_mb % 256 != 0:
raise RuntimeError("Requested memory must be a multiple of 256 MB.")
# Check if the requested memory isn't too little
if self.memory_mb < self.core_count * self.limits.min_mem_per_core:
raise RuntimeError(
f"Requested memory is too low. Minimal memory for {self.cpu_series.name} is {self.limits.min_mem_per_core} MB per core."
)
# Check if the requested memory isn't too much
if self.memory_mb > self.core_count * self.limits.max_mem_per_core:
if self.limits.allow_extra_memory:
if self.memory_mb > self.limits.extra_memory_limit:
raise RuntimeError(
f"Requested memory is too large.. Maximum memory allowed for {self.cpu_series.name} is {self.limits.extra_memory_limit} MB."
)
else:
raise RuntimeError(
f"Requested memory is too large.. Maximum memory allowed for {self.cpu_series.name} is {self.limits.max_mem_per_core} MB per core."
)
self._checked = True
def __str__(self) -> str:
"""
Return the custom machine type in form of a string acceptable by Compute Engine API.
"""
if self.cpu_series in {
self.CPUSeries.E2_SMALL,
self.CPUSeries.E2_MICRO,
self.CPUSeries.E2_MEDIUM,
}:
return f"zones/{self.zone}/machineTypes/{self.cpu_series.value}-{self.memory_mb}"
if self.extra_memory_used:
return f"zones/{self.zone}/machineTypes/{self.cpu_series.value}-{self.core_count}-{self.memory_mb}-ext"
return f"zones/{self.zone}/machineTypes/{self.cpu_series.value}-{self.core_count}-{self.memory_mb}"
def short_type_str(self) -> str:
"""
Return machine type in a format without the zone. For example, n2-custom-0-10240.
This format is used to create instance templates.
"""
return str(self).rsplit("/", maxsplit=1)[1]
@classmethod
def from_str(cls, machine_type: str):
"""
Construct a new object from a string. The string needs to be a valid custom machine type like:
- https://www.googleapis.com/compute/v1/projects/diregapic-mestiv/zones/us-central1-b/machineTypes/e2-custom-4-8192
- zones/us-central1-b/machineTypes/e2-custom-4-8192
- e2-custom-4-8192 (in this case, the zone parameter will not be set)
"""
zone = None
if machine_type.startswith("http"):
machine_type = machine_type[machine_type.find("zones/") :]
if machine_type.startswith("zones/"):
_, zone, _, machine_type = machine_type.split("/")
extra_mem = machine_type.endswith("-ext")
if machine_type.startswith("custom"):
cpu = cls.CPUSeries.N1
_, cores, memory = machine_type.rsplit("-", maxsplit=2)
else:
if extra_mem:
cpu_series, _, cores, memory, _ = machine_type.split("-")
else:
cpu_series, _, cores, memory = machine_type.split("-")
if cpu_series == "n2":
cpu = cls.CPUSeries.N2
elif cpu_series == "n2d":
cpu = cls.CPUSeries.N2D
elif cpu_series == "e2":
cpu = cls.CPUSeries.E2
if cores == "micro":
cpu = cls.CPUSeries.E2_MICRO
cores = 2
elif cores == "small":
cpu = cls.CPUSeries.E2_SMALL
cores = 2
elif cores == "medium":
cpu = cls.CPUSeries.E2_MEDIUM
cores = 2
else:
raise RuntimeError("Unknown CPU series.")
cores = int(cores)
memory = int(memory)
return cls(zone, cpu, memory, cores)
def get_image_from_family(project: str, family: str) -> compute_v1.Image:
"""
Retrieve the newest image that is part of a given family in a project.
Args:
project: project ID or project number of the Cloud project you want to get image from.
family: name of the image family you want to get image from.
Returns:
An Image object.
"""
image_client = compute_v1.ImagesClient()
# List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
newest_image = image_client.get_from_family(project=project, family=family)
return newest_image
def disk_from_image(
disk_type: str,
disk_size_gb: int,
boot: bool,
source_image: str,
auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
"""
Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
source for the new disk.
Args:
disk_type: the type of disk you want to create. This value uses the following format:
"zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
For example: "zones/us-west3-b/diskTypes/pd-ssd"
disk_size_gb: size of the new disk in gigabytes
boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
of the publicly available images or an image from one of your projects.
This value uses the following format: "projects/{project_name}/global/images/{image_name}"
auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it
Returns:
AttachedDisk object configured to be created using the specified image.
"""
boot_disk = compute_v1.AttachedDisk()
initialize_params = compute_v1.AttachedDiskInitializeParams()
initialize_params.source_image = source_image
initialize_params.disk_size_gb = disk_size_gb
initialize_params.disk_type = disk_type
boot_disk.initialize_params = initialize_params
# Remember to set auto_delete to True if you want the disk to be deleted when you delete
# your VM instance.
boot_disk.auto_delete = auto_delete
boot_disk.boot = boot
return boot_disk
def wait_for_extended_operation(
operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
"""
Waits for the extended (long-running) operation to complete.
If the operation is successful, it will return its result.
If the operation ends with an error, an exception will be raised.
If there were any warnings during the execution of the operation
they will be printed to sys.stderr.
Args:
operation: a long-running operation you want to wait on.
verbose_name: (optional) a more verbose name of the operation,
used only during error and warning reporting.
timeout: how long (in seconds) to wait for operation to finish.
If None, wait indefinitely.
Returns:
Whatever the operation.result() returns.
Raises:
This method will raise the exception received from `operation.exception()`
or RuntimeError if there is no exception set, but there is an `error_code`
set for the `operation`.
In case of an operation taking longer than `timeout` seconds to complete,
a `concurrent.futures.TimeoutError` will be raised.
"""
result = operation.result(timeout=timeout)
if operation.error_code:
print(
f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
file=sys.stderr,
flush=True,
)
print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
raise operation.exception() or RuntimeError(operation.error_message)
if operation.warnings:
print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
for warning in operation.warnings:
print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
return result
def create_instance(
project_id: str,
zone: str,
instance_name: str,
disks: list[compute_v1.AttachedDisk],
machine_type: str = "n1-standard-1",
network_link: str = "global/networks/default",
subnetwork_link: str = None,
internal_ip: str = None,
external_access: bool = False,
external_ipv4: str = None,
accelerators: list[compute_v1.AcceleratorConfig] = None,
preemptible: bool = False,
spot: bool = False,
instance_termination_action: str = "STOP",
custom_hostname: str = None,
delete_protection: bool = False,
) -> compute_v1.Instance:
"""
Send an instance creation request to the Compute Engine API and wait for it to complete.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
disks: a list of compute_v1.AttachedDisk objects describing the disks
you want to attach to your new instance.
machine_type: machine type of the VM being created. This value uses the
following format: "zones/{zone}/machineTypes/{type_name}".
For example: "zones/europe-west3-c/machineTypes/f1-micro"
network_link: name of the network you want the new instance to use.
For example: "global/networks/default" represents the network
named "default", which is created automatically for each project.
subnetwork_link: name of the subnetwork you want the new instance to use.
This value uses the following format:
"regions/{region}/subnetworks/{subnetwork_name}"
internal_ip: internal IP address you want to assign to the new instance.
By default, a free address from the pool of available internal IP addresses of
used subnet will be used.
external_access: boolean flag indicating if the instance should have an external IPv4
address assigned.
external_ipv4: external IPv4 address to be assigned to this instance. If you specify
an external IP address, it must live in the same region as the zone of the instance.
This setting requires `external_access` to be set to True to work.
accelerators: a list of AcceleratorConfig objects describing the accelerators that will
be attached to the new instance.
preemptible: boolean value indicating if the new instance should be preemptible
or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
spot: boolean value indicating if the new instance should be a Spot VM or not.
instance_termination_action: What action should be taken once a Spot VM is terminated.
Possible values: "STOP", "DELETE"
custom_hostname: Custom hostname of the new VM instance.
Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
delete_protection: boolean value indicating if the new virtual machine should be
protected against deletion or not.
Returns:
Instance object.
"""
instance_client = compute_v1.InstancesClient()
# Use the network interface provided in the network_link argument.
network_interface = compute_v1.NetworkInterface()
network_interface.network = network_link
if subnetwork_link:
network_interface.subnetwork = subnetwork_link
if internal_ip:
network_interface.network_i_p = internal_ip
if external_access:
access = compute_v1.AccessConfig()
access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
access.name = "External NAT"
access.network_tier = access.NetworkTier.PREMIUM.name
if external_ipv4:
access.nat_i_p = external_ipv4
network_interface.access_configs = [access]
# Collect information into the Instance object.
instance = compute_v1.Instance()
instance.network_interfaces = [network_interface]
instance.name = instance_name
instance.disks = disks
if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
instance.machine_type = machine_type
else:
instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
instance.scheduling = compute_v1.Scheduling()
if accelerators:
instance.guest_accelerators = accelerators
instance.scheduling.on_host_maintenance = (
compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
)
if preemptible:
# Set the preemptible setting
warnings.warn(
"Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
)
instance.scheduling = compute_v1.Scheduling()
instance.scheduling.preemptible = True
if spot:
# Set the Spot VM setting
instance.scheduling.provisioning_model = (
compute_v1.Scheduling.ProvisioningModel.SPOT.name
)
instance.scheduling.instance_termination_action = instance_termination_action
if custom_hostname is not None:
# Set the custom hostname for the instance
instance.hostname = custom_hostname
if delete_protection:
# Set the delete protection bit
instance.deletion_protection = True
# Prepare the request to insert an instance.
request = compute_v1.InsertInstanceRequest()
request.zone = zone
request.project = project_id
request.instance_resource = instance
# Wait for the create operation to complete.
print(f"Creating the {instance_name} instance in {zone}...")
operation = instance_client.insert(request=request)
wait_for_extended_operation(operation, "instance creation")
print(f"Instance {instance_name} created.")
return instance_client.get(project=project_id, zone=zone, instance=instance_name)
def create_custom_instance(
project_id: str,
zone: str,
instance_name: str,
cpu_series: CustomMachineType.CPUSeries,
core_count: int,
memory: int,
) -> compute_v1.Instance:
"""
Create a new VM instance with a custom machine type.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
cpu_series: the type of CPU you want to use. Select one value from the CustomMachineType.CPUSeries enum.
For example: CustomMachineType.CPUSeries.N2
core_count: number of CPU cores you want to use.
memory: the amount of memory for the VM instance, in megabytes.
Return:
Instance object.
"""
assert cpu_series in (
CustomMachineType.CPUSeries.E2,
CustomMachineType.CPUSeries.N1,
CustomMachineType.CPUSeries.N2,
CustomMachineType.CPUSeries.N2D,
)
custom_type = CustomMachineType(zone, cpu_series, memory, core_count)
newest_debian = get_image_from_family(project="debian-cloud", family="debian-10")
disk_type = f"zones/{zone}/diskTypes/pd-standard"
disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
return create_instance(project_id, zone, instance_name, disks, str(custom_type))
REST
Erstellen Sie mit der Methode instances.insert Ihre Anfrage zur Instanzerstellung wie gewohnt. Wenn Sie jedoch einen machineType-Wert angeben, verwenden Sie eines der folgenden Formate. Ersetzen Sie NUMBER_OF_CPUS durch die Anzahl der vCPUs und AMOUNT_OF_MEMORY_MB durch die gewünschte Speichermenge. Geben Sie die Speichergröße in MB an:
Für N1-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
Für N2-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/n2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
Für N2D-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/n2d-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
Für E2-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/e2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
Für benutzerdefinierte E2-Maschinentypen mit gemeinsam genutztem Kern verwenden Sie folgendes Format:
zones/ZONE/machineTypes/e2-custom-SHARED_CORE_MACHINE_SIZE-AMOUNT_OF_MEMORY_MB
So würde die folgende URL beispielsweise eine Instanz mit 4 vCPUs und 5 GB (5.120 MB) Speicher erstellen:
zones/us-central1-f/machineTypes/custom-4-5120
Ebenso können Sie Instanzen auf Abruf und Instanzgruppen mit benutzerdefinierten Maschinentypen erstellen.
Erweiterten Speicher einem Maschinentyp hinzufügen
Je nach Maschine hat jeder Maschinentyp standardmäßig eine bestimmte Menge an Arbeitsspeicher. Wenn Sie beispielsweise eine benutzerdefinierte N1-VM erstellen, kann diese bis zu 6,5 GB Speicher pro vCPU haben. Bei benutzerdefinierten N2-VMs erhöht sich der Wert auf bis zu 8 GB Arbeitsspeicher pro vCPU.
Für bestimmte Arbeitslasten ist dieser Arbeitsspeicher möglicherweise nicht ausreichend. Gegen einen Aufpreis können Sie den Speicher pro vCPU über die Standardgrenze hinaus erweitern. Dies wird als erweiterter Speicher bezeichnet.
Mit erweitertem Speicher können Sie einem Maschinentyp Arbeitsspeicher ohne Beschränkungen pro vCPU hinzufügen. Sie können erweiterten Speicher bis zu bestimmten Grenzwerten abhängig vom Maschinentyp hinzufügen:
- Für N1-Maschinentypen können Sie insgesamt 624 GB Arbeitsspeicher pro VM hinzufügen.
- Für N2-Maschinentypen können Sie insgesamt 640 GB Arbeitsspeicher pro VM hinzufügen.
- Für N2D-Maschinentypen können Sie insgesamt bis zu 768 GB Arbeitsspeicher pro VM hinzufügen.
- Erweiterter Speicher ist für E2-Maschinentypen nicht verfügbar.
Wenn Sie mehr Arbeitsspeicher benötigen, müssen Sie einen der speicheroptimierten Maschinentypen verwenden, mit denen Sie VMs mit einem Gesamtarbeitsspeicher von bis zu 12 TB pro VM erstellen können.
Weitere Informationen finden Sie unter Speicheroptimierte Maschinenfamilie.
Bedarf für erweiterten Speicher ermitteln
Für bestimmte Arbeitslasten ist der standardmäßig pro vCPU zugewiesene Arbeitsspeicher nicht ausreichend, um optimale Ergebnisse zu erzielen. Zu dieser Kategorie gehören Arbeitslasten, die auf speicherinternen Hochleistungs-Analysedatenbanken basieren, darunter relationale und NoSQL-Datenbanken wie MS SQL Server, MongoDB und MemcacheD/Redis. Die vCPU-basierte Lizenzierung von Betriebssystemen und Softwarestacks erschwert bei vordefinierten Maschinentypen außerdem die Wahl einer optimalen VM-Speicherkonfiguration. Durch die Nutzung von erweitertem Speicher können Sie so viel Speicher wie nötig für Ihre VMs hinzufügen, um das beste Preis-Leistungs-Verhältnis zu erzielen.
Preise
Bei Verwendung eines benutzerdefinierten Maschinentyps wird bis einschließlich der Standardmenge pro vCPU zum Preis für benutzerdefinierte N1-Maschinentypen oder zum Preis für benutzerdefinierte N2-Maschinentypen abgerechnet.
Benutzerdefinierte E2-Maschinen und benutzerdefinierte E2-Maschinentypen mit gemeinsam genutztem Kern haben das gleiche Preisschema.
Für Speicher oberhalb des Standardwerts berechnet Compute Engine eine Gebühr für den erweiterten Speicher auf Basis der Preise für erweiterten benutzerdefinierten N1-Speicher oder der Preise für erweiterten benutzerdefinierten N2-Speicher.
Der Preis für erweiterten Speicher unterscheidet sich von dem Preis für Speicher unterhalb des Standardschwellenwerts.
Die Preise für erweiterten Speicher unterscheiden sich je nach Region. Instanzen, die mit erweitertem Speicher ausgeführt werden, unterliegen derselben 1-Minuten-Mindestgebühr wie jede andere Instanz. Erweiterter Speicher berechtigt außerdem zu Rabatten für kontinuierliche Nutzung.
Weitere Informationen finden Sie unter Rabatte für kontinuierliche Nutzung für benutzerdefinierte Maschinentypen und Preise für erweiterten benutzerdefinierten Speicher.
Beschränkungen
- Wenn Ihre VM lokale SSD-Laufwerke hat, können Sie die vCPU- und Arbeitsspeicherkonfiguration nicht ändern.
- Erweiterter Speicher kann nur benutzerdefinierten Maschinentypen hinzugefügt werden. Vordefinierte Maschinentypen werden nicht unterstützt.
- Es gibt eine maximale Speichermenge, die Sie den einzelnen VM-Instanzen hinzufügen können. Für N1-Maschinentypen können Sie bis zu 624 GB Speicher hinzufügen. Für N2-Maschinentypen können Sie bis zu 640 GB Speicher hinzufügen. Für N2D-Maschinentypen können Sie bis zu 768 GB Arbeitsspeicher hinzufügen.
- Benutzerdefinierte N2D-Maschinentypen sind nur in ausgewählten Regionen und Zonen verfügbar.
- Sie müssen Speicher in Schritten von 256 MB angeben.
- Erweiterter Speicher berechtigt nicht zu Rabatten für zugesicherte Nutzung.
Erweiterten Speicher bei der Instanzerstellung hinzufügen
Führen Sie die folgenden Schritte aus, um eine VM-Instanz mit erweitertem Speicher zu erstellen.
Console
Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.
Zur Seite „Instanz erstellen“
Wählen Sie in der Liste Zone die Zone aus, in der diese VM gehostet werden soll. Die Liste Reihe wird so gefiltert, dass nur die in der ausgewählten Zone verfügbaren Maschinentypenfamilien enthalten sind.
Wählen Sie im Abschnitt Maschinenkonfiguration die Option Allgemeiner Zweck aus.
- Klicken Sie in der Liste Reihe auf N1 als Erste Generation für benutzerdefinierte N1-Maschinentypen oder N2 oder N2D als Zweite Generation für benutzerdefinierte Maschinentypen.
- Wählen Sie im Abschnitt Maschinentyp die Option Benutzerdefiniert aus.
- Ziehen Sie den Schieberegler Kerne oder geben Sie den Wert in das Textfeld ein, um die Anzahl der vCPUs anzugeben.
Wählen Sie Speicher erweitern aus und gehen Sie so vor, um erweiterten Speicher hinzuzufügen:
- Ziehen Sie den Schieberegler Arbeitsspeicher oder geben Sie den Wert in das Textfeld ein, um die Speichermenge für die VM-Instanz anzugeben.
In der Console wird eine Kostenschätzung für die Instanz angezeigt, wenn Sie die Anzahl der vCPUs und die Speichermenge ändern.
Fahren Sie mit dem Erstellen der VM fort.
gcloud
Verwenden Sie für N1-Maschinentypen den Befehl gcloud compute instances create mit dem Flag --custom-extensions, um erweiterten Speicher zu aktivieren. Geben Sie mit dem Parameter --custom-memory die gewünschte Speichermenge insgesamt an.
gcloud compute instances create example-instance \
--custom-extensions --custom-cpu=2 --custom-memory=15
Verwenden Sie für N2-Maschinentypen den Befehl gcloud compute instances create mit den Flags --custom-extensions, --custom-cpu und --custom-memory, gefolgt von dem --custom-vm-type-Flag zur Angabe des N2-Maschinentyps:
gcloud compute instances create example-instance \
--custom-extensions --custom-cpu=2 --custom-memory=16 \
--custom-vm-type=n2
Verwenden Sie für N2D-Maschinentypen den Befehl gcloud compute instances create mit den Flags --custom-extensions, --custom-cpu und --custom-memory, gefolgt von dem --custom-vm-type-Flag zur Angabe des N2D-Maschinentyps:
gcloud compute instances create example-instance \
--custom-extensions --custom-cpu=2 --custom-memory=16 \
--custom-vm-type=n2d
Python
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
from __future__ import annotations
import re
import sys
from typing import Any
import warnings
from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1
def get_image_from_family(project: str, family: str) -> compute_v1.Image:
"""
Retrieve the newest image that is part of a given family in a project.
Args:
project: project ID or project number of the Cloud project you want to get image from.
family: name of the image family you want to get image from.
Returns:
An Image object.
"""
image_client = compute_v1.ImagesClient()
# List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
newest_image = image_client.get_from_family(project=project, family=family)
return newest_image
def disk_from_image(
disk_type: str,
disk_size_gb: int,
boot: bool,
source_image: str,
auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
"""
Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
source for the new disk.
Args:
disk_type: the type of disk you want to create. This value uses the following format:
"zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
For example: "zones/us-west3-b/diskTypes/pd-ssd"
disk_size_gb: size of the new disk in gigabytes
boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
of the publicly available images or an image from one of your projects.
This value uses the following format: "projects/{project_name}/global/images/{image_name}"
auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it
Returns:
AttachedDisk object configured to be created using the specified image.
"""
boot_disk = compute_v1.AttachedDisk()
initialize_params = compute_v1.AttachedDiskInitializeParams()
initialize_params.source_image = source_image
initialize_params.disk_size_gb = disk_size_gb
initialize_params.disk_type = disk_type
boot_disk.initialize_params = initialize_params
# Remember to set auto_delete to True if you want the disk to be deleted when you delete
# your VM instance.
boot_disk.auto_delete = auto_delete
boot_disk.boot = boot
return boot_disk
def wait_for_extended_operation(
operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
"""
Waits for the extended (long-running) operation to complete.
If the operation is successful, it will return its result.
If the operation ends with an error, an exception will be raised.
If there were any warnings during the execution of the operation
they will be printed to sys.stderr.
Args:
operation: a long-running operation you want to wait on.
verbose_name: (optional) a more verbose name of the operation,
used only during error and warning reporting.
timeout: how long (in seconds) to wait for operation to finish.
If None, wait indefinitely.
Returns:
Whatever the operation.result() returns.
Raises:
This method will raise the exception received from `operation.exception()`
or RuntimeError if there is no exception set, but there is an `error_code`
set for the `operation`.
In case of an operation taking longer than `timeout` seconds to complete,
a `concurrent.futures.TimeoutError` will be raised.
"""
result = operation.result(timeout=timeout)
if operation.error_code:
print(
f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
file=sys.stderr,
flush=True,
)
print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
raise operation.exception() or RuntimeError(operation.error_message)
if operation.warnings:
print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
for warning in operation.warnings:
print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
return result
def create_instance(
project_id: str,
zone: str,
instance_name: str,
disks: list[compute_v1.AttachedDisk],
machine_type: str = "n1-standard-1",
network_link: str = "global/networks/default",
subnetwork_link: str = None,
internal_ip: str = None,
external_access: bool = False,
external_ipv4: str = None,
accelerators: list[compute_v1.AcceleratorConfig] = None,
preemptible: bool = False,
spot: bool = False,
instance_termination_action: str = "STOP",
custom_hostname: str = None,
delete_protection: bool = False,
) -> compute_v1.Instance:
"""
Send an instance creation request to the Compute Engine API and wait for it to complete.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
disks: a list of compute_v1.AttachedDisk objects describing the disks
you want to attach to your new instance.
machine_type: machine type of the VM being created. This value uses the
following format: "zones/{zone}/machineTypes/{type_name}".
For example: "zones/europe-west3-c/machineTypes/f1-micro"
network_link: name of the network you want the new instance to use.
For example: "global/networks/default" represents the network
named "default", which is created automatically for each project.
subnetwork_link: name of the subnetwork you want the new instance to use.
This value uses the following format:
"regions/{region}/subnetworks/{subnetwork_name}"
internal_ip: internal IP address you want to assign to the new instance.
By default, a free address from the pool of available internal IP addresses of
used subnet will be used.
external_access: boolean flag indicating if the instance should have an external IPv4
address assigned.
external_ipv4: external IPv4 address to be assigned to this instance. If you specify
an external IP address, it must live in the same region as the zone of the instance.
This setting requires `external_access` to be set to True to work.
accelerators: a list of AcceleratorConfig objects describing the accelerators that will
be attached to the new instance.
preemptible: boolean value indicating if the new instance should be preemptible
or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
spot: boolean value indicating if the new instance should be a Spot VM or not.
instance_termination_action: What action should be taken once a Spot VM is terminated.
Possible values: "STOP", "DELETE"
custom_hostname: Custom hostname of the new VM instance.
Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
delete_protection: boolean value indicating if the new virtual machine should be
protected against deletion or not.
Returns:
Instance object.
"""
instance_client = compute_v1.InstancesClient()
# Use the network interface provided in the network_link argument.
network_interface = compute_v1.NetworkInterface()
network_interface.network = network_link
if subnetwork_link:
network_interface.subnetwork = subnetwork_link
if internal_ip:
network_interface.network_i_p = internal_ip
if external_access:
access = compute_v1.AccessConfig()
access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
access.name = "External NAT"
access.network_tier = access.NetworkTier.PREMIUM.name
if external_ipv4:
access.nat_i_p = external_ipv4
network_interface.access_configs = [access]
# Collect information into the Instance object.
instance = compute_v1.Instance()
instance.network_interfaces = [network_interface]
instance.name = instance_name
instance.disks = disks
if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
instance.machine_type = machine_type
else:
instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
instance.scheduling = compute_v1.Scheduling()
if accelerators:
instance.guest_accelerators = accelerators
instance.scheduling.on_host_maintenance = (
compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
)
if preemptible:
# Set the preemptible setting
warnings.warn(
"Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
)
instance.scheduling = compute_v1.Scheduling()
instance.scheduling.preemptible = True
if spot:
# Set the Spot VM setting
instance.scheduling.provisioning_model = (
compute_v1.Scheduling.ProvisioningModel.SPOT.name
)
instance.scheduling.instance_termination_action = instance_termination_action
if custom_hostname is not None:
# Set the custom hostname for the instance
instance.hostname = custom_hostname
if delete_protection:
# Set the delete protection bit
instance.deletion_protection = True
# Prepare the request to insert an instance.
request = compute_v1.InsertInstanceRequest()
request.zone = zone
request.project = project_id
request.instance_resource = instance
# Wait for the create operation to complete.
print(f"Creating the {instance_name} instance in {zone}...")
operation = instance_client.insert(request=request)
wait_for_extended_operation(operation, "instance creation")
print(f"Instance {instance_name} created.")
return instance_client.get(project=project_id, zone=zone, instance=instance_name)
def create_custom_instances_extra_mem(
project_id: str, zone: str, instance_name: str, core_count: int, memory: int
) -> list[compute_v1.Instance]:
"""
Create 3 new VM instances with extra memory without using a CustomMachineType helper class.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
core_count: number of CPU cores you want to use.
memory: the amount of memory for the VM instance, in megabytes.
Returns:
List of Instance objects.
"""
newest_debian = get_image_from_family(project="debian-cloud", family="debian-10")
disk_type = f"zones/{zone}/diskTypes/pd-standard"
disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
# The core_count and memory values are not validated anywhere and can be rejected by the API.
instances = [
create_instance(
project_id,
zone,
f"{instance_name}_n1_extra_mem",
disks,
f"zones/{zone}/machineTypes/custom-{core_count}-{memory}-ext",
),
create_instance(
project_id,
zone,
f"{instance_name}_n2_extra_mem",
disks,
f"zones/{zone}/machineTypes/n2-custom-{core_count}-{memory}-ext",
),
create_instance(
project_id,
zone,
f"{instance_name}_n2d_extra_mem",
disks,
f"zones/{zone}/machineTypes/n2d-custom-{core_count}-{memory}-ext",
),
]
return instances
REST
Nutzen Sie die Methode instances.insert, um die Anfrage zur Generierung einer Instanz zu erstellen. Wenn Sie aber einen Wert für machineType angeben, verwenden Sie eines der folgenden Formate:
Für N1-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Für N2-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/n2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Für N2D-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/n2d-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Ersetzen Sie Folgendes:
NUMBER_OF_CPUS: Die Anzahl der vCPUs.AMOUNT_OF_MEMORY: Der Arbeitsspeicher in MB.
Die folgende Eingabe gibt beispielsweise einen N2-Maschinentyp mit 2 vCPUs und 20 GB Arbeitsspeicher an:
zones/ZONE/machineTypes/n2-custom-2-20480-ext
Erweiterten Speicher zu einer bestehenden VM-Instanz hinzufügen
Wenn Sie einer bestehenden Instanz weiteren Speicher hinzufügen möchten, müssen Sie
die Instanz zuerst beenden.
Wenn die Instanz beendet wurde, führen Sie die folgenden Schritte aus, um der VM zusätzlichen Speicher hinzuzufügen.
Console
Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.
Zu „VM-Instanzen“
Wählen Sie in der Liste der VMs die beendete VM aus, die Sie ändern möchten.
Klicken Sie oben auf der Seite auf Bearbeiten.
Wählen Sie unter Maschinenkonfigurationen die Option Allgemeiner Zweck aus.
Wählen Sie im Abschnitt Maschinentyp die Option Benutzerdefiniert aus.
Wählen Sie die gewünschte Anzahl von vCPUs aus.
Wählen Sie Speicher erweitern aus und geben Sie dann die gewünschte Speichermenge ein.
Speichern Sie die Änderungen.
gcloud
Verwenden Sie den compute instances set-machine-type-Befehl mit den Flags --custom-memory und --custom-extensions.
Wenn Sie beispielsweise 2 GB Arbeitsspeicher zu einer VM-Instanz mit dem Namen example-instance hinzufügen möchten, die derzeit den Maschinentyp N1 mit 2 vCPUs und 13 GB in der Zone us-central1-b hat, geben Sie folgenden Befehl ein:
gcloud compute instances set-machine-type example-instance \
--zone=us-central1-b --custom-cpu=2 \
--custom-memory=15 --custom-extensions
Einfach loslegen (Go)
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
import (
"context"
"fmt"
"io"
"strings"
compute "cloud.google.com/go/compute/apiv1"
computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
"google.golang.org/protobuf/proto"
)
// modifyInstanceWithExtendedMemory sends an instance creation request
// to the Compute Engine API and waits for it to complete.
func modifyInstanceWithExtendedMemory(
w io.Writer,
projectID, zone, instanceName string,
newMemory int,
) error {
// projectID := "your_project_id"
// zone := "europe-central2-b"
// instanceName := "your_instance_name"
// newMemory := 256 // the amount of memory for the VM instance, in megabytes.
ctx := context.Background()
instancesClient, err := compute.NewInstancesRESTClient(ctx)
if err != nil {
return fmt.Errorf("NewInstancesRESTClient: %w", err)
}
defer instancesClient.Close()
reqInstance := &computepb.GetInstanceRequest{
Project: projectID,
Zone: zone,
Instance: instanceName,
}
instance, err := instancesClient.Get(ctx, reqInstance)
if err != nil {
return fmt.Errorf("unable to get instance: %w", err)
}
containsString := func(s []string, str string) bool {
for _, v := range s {
if v == str {
return true
}
}
return false
}
if !(strings.Contains(instance.GetMachineType(), "machineTypes/n1-") ||
strings.Contains(instance.GetMachineType(), "machineTypes/n2-") ||
strings.Contains(instance.GetMachineType(), "machineTypes/n2d-")) {
return fmt.Errorf("extra memory is available only for N1, N2 and N2D CPUs")
}
// Make sure that the machine is turned off
if !containsString([]string{"TERMINATED", "STOPPED"}, instance.GetStatus()) {
reqStop := &computepb.StopInstanceRequest{
Project: projectID,
Zone: zone,
Instance: instanceName,
}
op, err := instancesClient.Stop(ctx, reqStop)
if err != nil {
return fmt.Errorf("unable to stop instance: %w", err)
}
if err = op.Wait(ctx); err != nil {
return fmt.Errorf("unable to wait for the operation: %w", err)
}
}
// Modify the machine definition, remember that extended memory
// is available only for N1, N2 and N2D CPUs
machineType := instance.GetMachineType()
start := machineType[:strings.LastIndex(machineType, "-")]
updateReq := &computepb.SetMachineTypeInstanceRequest{
Project: projectID,
Zone: zone,
Instance: instanceName,
InstancesSetMachineTypeRequestResource: &computepb.InstancesSetMachineTypeRequest{
MachineType: proto.String(fmt.Sprintf("%s-%v-ext", start, newMemory)),
},
}
op, err := instancesClient.SetMachineType(ctx, updateReq)
if err != nil {
return fmt.Errorf("unable to update instance: %w", err)
}
if err = op.Wait(ctx); err != nil {
return fmt.Errorf("unable to wait for the operation: %w", err)
}
fmt.Fprintf(w, "Instance updated\n")
return nil
}
Python
Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken.
Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.
Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren.
Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.
from __future__ import annotations
import sys
import time
from typing import Any
from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1
def wait_for_extended_operation(
operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
"""
Waits for the extended (long-running) operation to complete.
If the operation is successful, it will return its result.
If the operation ends with an error, an exception will be raised.
If there were any warnings during the execution of the operation
they will be printed to sys.stderr.
Args:
operation: a long-running operation you want to wait on.
verbose_name: (optional) a more verbose name of the operation,
used only during error and warning reporting.
timeout: how long (in seconds) to wait for operation to finish.
If None, wait indefinitely.
Returns:
Whatever the operation.result() returns.
Raises:
This method will raise the exception received from `operation.exception()`
or RuntimeError if there is no exception set, but there is an `error_code`
set for the `operation`.
In case of an operation taking longer than `timeout` seconds to complete,
a `concurrent.futures.TimeoutError` will be raised.
"""
result = operation.result(timeout=timeout)
if operation.error_code:
print(
f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
file=sys.stderr,
flush=True,
)
print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
raise operation.exception() or RuntimeError(operation.error_message)
if operation.warnings:
print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
for warning in operation.warnings:
print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
return result
def add_extended_memory_to_instance(
project_id: str, zone: str, instance_name: str, new_memory: int
):
"""
Modify an existing VM to use extended memory.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
new_memory: the amount of memory for the VM instance, in megabytes.
Returns:
Instance object.
"""
instance_client = compute_v1.InstancesClient()
instance = instance_client.get(
project=project_id, zone=zone, instance=instance_name
)
if not (
"n1-" in instance.machine_type
or "n2-" in instance.machine_type
or "n2d-" in instance.machine_type
):
raise RuntimeError("Extra memory is available only for N1, N2 and N2D CPUs.")
# Make sure that the machine is turned off
if instance.status not in (
instance.Status.TERMINATED.name,
instance.Status.STOPPED.name,
):
operation = instance_client.stop(
project=project_id, zone=zone, instance=instance_name
)
wait_for_extended_operation(operation, "instance stopping")
start = time.time()
while instance.status not in (
instance.Status.TERMINATED.name,
instance.Status.STOPPED.name,
):
# Waiting for the instance to be turned off.
instance = instance_client.get(
project=project_id, zone=zone, instance=instance_name
)
time.sleep(2)
if time.time() - start >= 300: # 5 minutes
raise TimeoutError()
# Modify the machine definition, remember that extended memory is available only for N1, N2 and N2D CPUs
start, end = instance.machine_type.rsplit("-", maxsplit=1)
instance.machine_type = start + f"-{new_memory}-ext"
# TODO: If you prefer to use the CustomMachineType helper class, uncomment this code and comment the 2 lines above
# Using CustomMachineType helper
# cmt = CustomMachineType.from_str(instance.machine_type)
# cmt.memory_mb = new_memory
# cmt.extra_memory_used = True
# instance.machine_type = str(cmt)
operation = instance_client.update(
project=project_id,
zone=zone,
instance=instance_name,
instance_resource=instance,
)
wait_for_extended_operation(operation, "instance update")
return instance_client.get(project=project_id, zone=zone, instance=instance_name)
REST
Stellen Sie eine POST-Anfrage an die Methode instances.setMachineType mit dem gewünschten Maschinentyp im Anfragetext. Verwenden Sie eines der folgenden Formate:
Für N1-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Für N2-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/n2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Für N2D-Maschinentypen verwenden Sie folgendes Format:
zones/ZONE/machineTypes/n2d-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Ersetzen Sie Folgendes:
NUMBER_OF_CPUS: Die Anzahl der vCPUs.AMOUNT_OF_MEMORY: Der Arbeitsspeicher in MB.
Die folgende Anfrage gibt beispielsweise einen N1-Maschinentyp mit 2 vCPUs und 15 GB Arbeitsspeicher an:
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/setMachineType
{
machineType: "zones/us-central1-f/machineTypes/custom-2-15360-ext"
}
Nächste Schritte
