diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.de-de.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.de-de.md index ef2723b981c..ebfcac6a9d1 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.de-de.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.de-de.md @@ -1,13 +1,9 @@ --- title: 'vRack auf Ihren Dedicated Servern konfigurieren' excerpt: 'Erfahren Sie hier, wie Sie ein vRack auf zwei oder mehr Servern einrichten' -updated: 2024-10-17 +updated: 2025-03-24 --- -> [!primary] -> Diese Übersetzung wurde durch unseren Partner SYSTRAN automatisch erstellt. In manchen Fällen können ungenaue Formulierungen verwendet worden sein, z.B. bei der Beschriftung von Schaltflächen oder technischen Details. Bitte ziehen Sie im Zweifelsfall die englische oder französische Fassung der Anleitung zu Rate. Möchten Sie mithelfen, diese Übersetzung zu verbessern? Dann nutzen Sie dazu bitte den Button "Beitragen" auf dieser Seite. -> - ## Ziel Das OVHcloud vRack (Virtual Rack) erlaubt es, mehrere Server (unabhängig von deren Anzahl und physischem Standort in unseren Rechenzentren) virtuell zusammenzufassen und diese über einen virtuellen Switch innerhalb eines privaten Netzwerks zu verbinden. Ihre Server können so privat und abgesichert über ein dediziertes VLAN untereinander kommunizieren. @@ -60,9 +56,9 @@ Die nachfolgenden Konfigurationsdetails verwenden zu Beispielzwecken den IP-Adre Sie können aber einen privaten IP-Bereich Ihrer Wahl und jede beliebige Adresse in diesem Bereich verwenden. > -#### GNU/Linux Konfigurationen +#### Identifikation des vRack Interface -Die Namen der Netzwerkinterfaces Ihrer Server sind nicht immer die gleichen. Ersetzen Sie in den nachfolgenden Beispielen NETWORK_INTERFACE stets mit der korrekten Interface-Bezeichnung. +Die Namen der Netzwerkinterfaces Ihrer Server sind nicht immer gleich. Der sicherste Weg, das richtige Interface für das vRack zu bestimmen, ist das Prüfen des Server-Tabs `Netzwerkinterfaces`{.action} im [OVHcloud Kundencenter](/links/manager). Notieren Sie sich aus der Tabelle am Seitenende die **MAC-Adresse** des Interfaces vom Typ **Privat**, die in dieser Ansicht auch als "Name" angezeigt wird. @@ -74,30 +70,36 @@ Sobald Sie via SSH mit Ihrem Server verbunden sind, können Sie Ihre Netzwerkint ip a ``` -In der mit ```link ether``` beginnenden Zeile können Sie verifizieren, dass das Interface dem als **Privat** definierten im [OVHcloud Kundencenter](/links/manager) entspricht. Verwenden Sie also den zugehörigen Interfacenamen, um `NETWORK_INTERFACE` in den folgenden Konfigurationen zu ersetzen. (Beispielname: `eno2`) +In der mit ```link ether``` beginnenden Zeile können Sie verifizieren, dass das Interface dem als **Privat** definierten im [OVHcloud Kundencenter](/links/manager) entspricht. Verwenden Sie also den zugehörigen Interfacenamen, um `NETWORK_INTERFACE` in den folgenden Konfigurationen zu ersetzen. (Beispielname: `eth1`) ```console link ether f0:00:00:ef:0e:f0 ``` +#### GNU/Linux Konfigurationen + ##### **Debian 12** Bearbeiten Sie mit einem beliebigen Texteditor die Netzwerkkonfigurationsdatei in `/etc/netplan/`. Hier heißt die Datei `50-cloud-init.yaml`: ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Fügen Sie die IP-Konfiguration zu den bereits vorhandenen Zeilen hinzu, unterhalb der Zeile `ethernets:`: +Fügen Sie die folgenden Zeilen nach der Zeile `version: 2` zur vorhandenen Konfiguration hinzu. Ersetzen Sie `NETWORK_INTERFACE` und `IP_ADDRESS/PREFIX` durch eigene Werte. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Beispiel** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Es ist wichtig, die Zeilenausrichtung jedes Elements in den `yaml`-Dateien wie im vorstehenden Beispiel dargestellt einzuhalten. Verwenden Sie nicht die Tabulationstaste, um den Abstand zu erzeugen. Nur die Leertaste ist notwendig. @@ -108,7 +110,7 @@ Speichern Sie Ihre Änderungen der Konfigurationsdatei und schließen Sie den Ed Verwenden Sie folgenden Befehl, um die Konfiguration anzuwenden: ```bash -netplan apply +sudo netplan apply ``` Wiederholen Sie diesen Vorgang für Ihre anderen Server und weisen Sie jedem Server eine noch ungenutzte IP-Adresse aus Ihrem privaten Bereich zu. Ihre Server können dann über das private Netzwerk untereinander kommunizieren. @@ -121,21 +123,25 @@ Bearbeiten Sie mit einem beliebigen Texteditor die Netzwerkkonfigurationsdatei i editor /etc/network/interfaces.d/50-cloud-init ``` -Fügen Sie folgende Zeilen hinzu: +Fügen Sie der vorhandenen Konfiguration die folgenden Zeilen hinzu. Ersetzen Sie `NETWORK_INTERFACE`, `IP_ADDRESS` und `NETMASK` durch eigene Werte: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Beispiel:** + +![debian config](images/debian_configuration.png){.thumbnail} + Speichern Sie Ihre Änderungen der Konfigurationsdatei und schließen Sie den Editor. Starten Sie den Netzwerkdienst neu, um die Konfiguration anzuwenden: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Wiederholen Sie diesen Vorgang für Ihre anderen Server und weisen Sie jedem Server eine noch ungenutzte IP-Adresse aus Ihrem privaten Bereich zu. Ihre Server können dann über das private Netzwerk untereinander kommunizieren. @@ -145,19 +151,23 @@ Wiederholen Sie diesen Vorgang für Ihre anderen Server und weisen Sie jedem Ser Bearbeiten Sie mit einem beliebigen Texteditor die Netzwerkkonfigurationsdatei in `/etc/netplan/`. Hier heißt die Datei `50-cloud-init.yaml`: ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Fügen Sie die IP-Konfiguration zu den bereits vorhandenen Zeilen hinzu, unterhalb der Zeile `ethernets:`: +Fügen Sie die folgenden Zeilen nach der Zeile `version: 2` zur vorhandenen Konfiguration hinzu. Ersetzen Sie `NETWORK_INTERFACE` und `IP_ADDRESS/PREFIX` durch eigene Werte. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Beispiel:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Es ist wichtig, die Zeilenausrichtung jedes Elements in den `yaml`-Dateien wie im vorstehenden Beispiel dargestellt einzuhalten. Verwenden Sie nicht die Tabulationstaste, um den Abstand zu erzeugen. Nur die Leertaste ist notwendig. @@ -168,46 +178,144 @@ Speichern Sie Ihre Änderungen der Konfigurationsdatei und schließen Sie den Ed Verwenden Sie folgenden Befehl, um die Konfiguration anzuwenden: ```bash -netplan apply +sudo netplan apply ``` Wiederholen Sie diesen Vorgang für Ihre anderen Server und weisen Sie jedem Server eine noch ungenutzte IP-Adresse aus Ihrem privaten Bereich zu. Ihre Server können dann über das private Netzwerk untereinander kommunizieren. -##### **CentOS** +##### **CentOS, AlmaLinux und RockyLinux** -Bearbeiten Sie mit einem beliebigen Texteditor die Netzwerkkonfigurationsdatei `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Nachdem Sie Ihr privates Netzwerkinterface identifiziert haben, erstellen Sie mit dem Texteditor Ihrer Wahl die folgende Netzwerkkonfigurationsdatei. Ersetzen Sie `NETWORK_INTERFACE` durch Ihren eigenen Wert. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Fügen Sie diese Zeilen hinzu: +Fügen Sie diese Zeilen hinzu und ersetzen Sie `NETWORK_INTERFACE`, `IP_ADDRESS` und `NETMASK` durch Ihre eigenen Werte: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Beispiel:** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Speichern Sie Ihre Änderungen der Konfigurationsdatei und schließen Sie den Editor. Starten Sie den Netzwerkdienst neu, um die Änderungen anzuwenden: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -Verwenden Sie in **CentOS 8** diesen Befehl: +Verwenden Sie in **CentOS 8, AlmaLinux und RockyLinux** diesen Befehl: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Wiederholen Sie diesen Vorgang für Ihre anderen Server und weisen Sie jedem Server eine noch ungenutzte IP-Adresse aus Ihrem privaten Bereich zu. Ihre Server können dann über das private Netzwerk untereinander kommunizieren. +##### Fedora + +Sobald Sie den Namen Ihrer privaten Schnittstelle identifiziert haben (wie [hier](#vrack-interface) erklärt), führen Sie folgenden Befehl aus, um sicherzustellen, dass sie korrekt verbunden ist. In unserem Beispiel heißt das Interface `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Wenn der Zustand von `DEVICE` in der Zeile `STATE` als `disconnected` erscheint, muss das Interface vor der Konfiguration der IP erst verbunden werden. + +Beim Hinzufügen einer **ethernet**-Verbindung müssen wir ein Konfigurationsprofil erstellen, das wir dann einem Interface zuweisen. + +Führen Sie den folgenden Befehl aus und ersetzen Sie `INTERFACE_NAME` und `CONNECTION_NAME` durch eigene Werte. + +In unserem Beispiel haben wir dem Konfigurationsprofil den Namen `private-interface` gegeben. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Beispiel:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Stellen Sie sicher, dass das Interface ordnungsgemäß verbunden wurde: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Danach wird im Ordner `/etc/NetworkManager/system-connections` eine neue Konfigurationsdatei mit dem Namen *xxxxxxxx.nmconnection* erstellt. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Sie können diese Datei dann mit `nmcli` bearbeiten und `IP_ADDRESS`, `PREFIX` und `CONNECTION_NAME` durch eigene Werte ersetzen. + +- Fügen Sie Ihre IP hinzu: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Beispiel:** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Ändern Sie die Konfiguration von **auto** in **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Beispiel:** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Persistente Konfiguration: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Beispiel:** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Starten Sie den Netzwerkdienst mit folgendem Befehl neu: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows-Konfiguration Die folgenden Konfigurationen verwenden beispielhaft den IP-Adressbereich `192.168.0.0/16` (**Subnetzmaske**: `255.255.0.0`). @@ -250,4 +358,4 @@ Wiederholen Sie diesen Vorgang für Ihre anderen Server und weisen Sie jedem Ser [Mehrere VLANs im vRack erstellen](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Treten Sie unserer [User Community](/links/community) bei. \ No newline at end of file +Treten Sie unserer [User Community](/links/community) bei. diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-asia.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-asia.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-asia.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-asia.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-au.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-au.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-au.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-au.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ca.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ca.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ca.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ca.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-gb.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-gb.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-gb.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-gb.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ie.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ie.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ie.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-ie.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-sg.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-sg.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-sg.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-sg.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-us.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-us.md index 071bfaf72dc..686c3bab4bb 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-us.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.en-us.md @@ -1,7 +1,7 @@ --- title: 'Configuring the vRack on your dedicated servers' excerpt: 'Find out how to configure the vRack on two or more dedicated servers' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objective @@ -56,9 +56,9 @@ For example purposes, the configuration details below will have the IP address r You can use any private IP range of your choice and any address within that range. > -#### GNU/Linux configurations +#### Identifying the vRack interface -The network interface names of your servers are not always the same. Whenever used in the following examples, replace NETWORK_INTERFACE with the appropriate interface name. +The network interface names of your servers are not always the same. The sure way to verify the correct interface for the vRack is to check the tab `Network interfaces`{.action} of your server in the [OVHcloud Control Panel](/links/manager). In the table at the bottom, take note of the MAC address which is also the **Name** of the **Private** interface. @@ -70,30 +70,40 @@ Once connected to your server via SSH, you can list your network interfaces with ip a ``` -In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eno2`). +In the line that begins with ```link ether```, you can verify that this interface matches the **Private** interface listed in your [OVHcloud Control Panel](/links/manager). Use this interface name to replace `NETWORK_INTERFACE` in the configurations below (example: `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +For example purposes, we will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). + + +#### GNU/Linux configurations + ##### **Debian 12** Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE` and `IP_ADDRESS/PREFIX` with your own values. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -104,7 +114,7 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -114,24 +124,28 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/network/interfaces.d` for editing. Here the file is called `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Add the following lines: +Add the following lines to the existing configuration, replace `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Example** + +![debian config](images/debian_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the configuration: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. @@ -141,19 +155,23 @@ Repeat this process for your other server(s) and assign an unused IP address fro Using a text editor of your choice, open the network configuration file located in `/etc/netplan/` for editing. Here the file is called `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Add the IP configuration to the existing one after the line `ethernets`: +Add the following lines to the existing configuration after the line `version: 2`. Replace `NETWORK_INTERFACE`and `IP_ADDRESS/PREFIX` with your own valueS. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Example** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > It is important to respect the alignment of each element in `yaml` files as represented in the example above. Do not use the tab key to create your spacing. Only the space key is needed. @@ -164,46 +182,158 @@ Save your changes to the config file and exit the editor. Apply the configuration: ```bash -netplan apply +sudo netplan apply ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. -##### **CentOS** +##### **CentOS, AlmaLinux and RockyLinux** + +Once you have identified your private network interface, use the following command to create a network configuration file. + +Replace `NETWORK_INTERFACE` with your own value. + +```bash +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +``` -Using a text editor of your choice, open the file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +For example, if the private interface is named `eth1`, we have the following: ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-eth1 ``` -Add these lines: +Next, use a text editor of your choice to edit this file. + +```bash +sudo nano /etc/sysconfig/network-scripts/ifcfg-eth1 +``` + +Add these lines, replacing `NETWORK_INTERFACE`, `IP_ADDRESS` and `NETMASK` with your own values: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Example** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Save your changes to the config file and exit the editor. Restart the networking service to apply the changes: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -On **CentOS 8** use this command: +On **CentOS 8, AlmaLinux and RockyLinux**, use this command: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repeat this process for your other server(s) and assign an unused IP address from your private range. Once you have done this, your servers will be able to communicate with each other on the private network. +##### Fedora + +Once you have identified the name of your private interface (as explained [here](#vrack-interface)), verify that is it connected. In our example, our interface is called `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +If the `STATE` of the `DEVICE` appears as `disconnected`, it must be connected before configuring the IP. + +When adding an **ethernet** connection, we have to create a configuration profile which we then assign to a device. + +Run the following command, replacing `INTERFACE_NAME` and `CONNECTION_NAME` with your own values. + +In our example, we named our configuration profile `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Example:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +Check that the interface has been connected correctly: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Once this is done, a new configuration file named *xxxxxxxxxx.nmconnection* will be created in the folder `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +You can then edit this file using the `nmcli` handler, replacing `IP_ADDRESS`, `PREFIX` and `CONNECTION_NAME` with your own values. + +- Add your IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**example** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Change the configuration from **auto** to **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**example** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Make the configuration persistent: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**example** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +Reboot your network with the following command: + +```bash +sudo systemctl restart NetworkManager +``` + #### Windows configuration For example purposes, the following configurations will use the IP address range of `192.168.0.0/16` (**Subnet mask**: `255.255.0.0`). @@ -246,4 +376,4 @@ Repeat this process for your other server(s) and assign an unused IP address fro [Creating multiple vLANs in a vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack) -Join our [community of users](/links/community). +Join our [community of users](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-es.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-es.md index 34f12bccdbf..5b2ed88ca4f 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-es.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-es.md @@ -1,13 +1,9 @@ --- title: 'Configurar varios servidores dedicados en el vRack' excerpt: 'Cómo configurar varios servidores dedicados en el vRack' -updated: 2024-10-17 +updated: 2025-03-24 --- -> [!primary] -> Esta traducción ha sido generada de forma automática por nuestro partner SYSTRAN. En algunos casos puede contener términos imprecisos, como en las etiquetas de los botones o los detalles técnicos. En caso de duda, le recomendamos que consulte la versión inglesa o francesa de la guía. Si quiere ayudarnos a mejorar esta traducción, por favor, utilice el botón «Contribuir» de esta página. -> - ## Objetivo El vRack (rack virtual) de OVHcloud permite agrupar virtualmente varios servidores (independientemente de su número y su ubicación física en nuestros datacenters) y conectarlos a un switch virtual dentro de una misma red privada. De este modo, sus servidores pueden comunicarse entre sí de forma privada y segura, dentro de una VLAN dedicada. @@ -60,9 +56,9 @@ Por ejemplo, los siguientes detalles de configuración tendrán la dirección IP Puede utilizar cualquier rango de IP privadas de su elección y cualquier dirección dentro de este rango. > -#### Configuraciones GNU/Linux +#### Identificación de la interfaz vRack -Los nombres de las interfaces de red de los servidores no son siempre los mismos. En los siguientes ejemplos, sustituya NETWORK_INTERFACE por el nombre de interfaz apropiado. +Los nombres de las interfaces de red de los servidores no son siempre los mismos. La mejor forma de comprobar la interfaz del vRack es comprobar la pestaña `Interfaces de red`{.action} del servidor en el [Panel de configuración de OVHcloud](/links/manager). En la tabla inferior, tenga en cuenta la dirección MAC, que es también el **Nombre** de la interfaz **privada**. @@ -80,24 +76,30 @@ En la línea que empieza por ```link ether```, puede comprobar que esta interfaz link ether f0:00:00:ef:0e:f0 ``` +#### Configuraciones GNU/Linux + ##### **Debian 12** Utilice el editor de texto que desee para editar el archivo de configuración de red situado en `/etc/netplan/`. El archivo se llama `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Añada la configuración IP a la configuración existente después de la línea `ethernets`: +Añada las siguientes líneas a la configuración existente después de la línea `version: 2`. Sustituya `NETWORK_INTERFACE` y `IP_ADDRESS/PREFIX` por sus propios valores. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Ejemplo:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Es importante respetar la alineación de cada elemento en los archivos `yaml` como se muestra en el ejemplo anterior. No use la tecla de tabulación para crear el espacio. Sólo se debe utilizar la tecla espacio. @@ -108,7 +110,7 @@ Guarde los cambios en el archivo de configuración y salga del editor. Aplique la configuración: ```bash -netplan apply +sudo netplan apply ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. @@ -118,24 +120,28 @@ Repita este procedimiento para los demás servidores y asígnele a cada uno de e En un editor de texto, abra el archivo de configuración de red en `/etc/network/interfaces.d` para cambiarlo. El archivo se llama `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Añada las siguientes líneas: +Añada las siguientes líneas a la configuración existente, sustituya `NETWORK_INTERFACE`, `IP_ADDRESS` y `NETMASK` por sus propios valores: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Ejemplo:** + +![debian config](images/debian_configuration.png){.thumbnail} + Guarde los cambios en el archivo de configuración y salga del editor. Reinicie el servicio de red para aplicar la configuración: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. @@ -145,19 +151,23 @@ Repita este procedimiento para los demás servidores y asígnele a cada uno de e Utilice el editor de texto que desee para editar el archivo de configuración de red situado en `/etc/netplan/`. El archivo se llama `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Añada la configuración IP a la configuración existente después de la línea `ethernets`: +Añada las siguientes líneas a la configuración existente después de la línea `version: 2`. Sustituya `NETWORK_INTERFACE` y `IP_ADDRESS/PREFIX` por sus propios valores. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Ejemplo:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Es importante respetar la alineación de cada elemento en los archivos `yaml` como se muestra en el ejemplo anterior. No use la tecla de tabulación para crear el espacio. Sólo se debe utilizar la tecla espacio. @@ -168,46 +178,144 @@ Guarde los cambios en el archivo de configuración y salga del editor. Aplique la configuración: ```bash -netplan apply +sudo netplan apply ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. -##### **CentOS** +##### **CentOS, AlmaLinux y RockyLinux** -Utilice el editor de texto que desee para abrir el archivo `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Una vez que haya identificado la interfaz de red privada, utilice el editor de texto que desee para crear el siguiente archivo de configuración de red. Sustituya `NETWORK_INTERFACE` por su propio valor. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Añadir estas líneas: +Añada estas líneas, sustituyendo `NETWORK_INTERFACE`, `IP_ADDRESS` y `NETMASK` por sus propios valores: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Ejemplo:** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Guarde los cambios en el archivo de configuración y salga del editor. Reinicie el servicio de red para aplicar los cambios: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -En **CentOS 8**, utilice el siguiente comando: +En **CentOS 8, AlmaLinux y RockyLinux** utilice el siguiente comando: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. +##### Fedora + +Una vez que haya identificado el nombre de su interfaz privada (como se explica [aquí](#vrack-interface)), ejecute el siguiente comando para comprobar que esté conectada. En nuestro ejemplo, nuestra interfaz se denomina `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Si el `STATE` del `DEVICE` aparece como `disconnected`, es necesario conectarlo antes de configurar la IP. + +Al añadir una conexión **ethernet**, es necesario crear un perfil de configuración y asignarlo a un dispositivo. + +Ejecute el siguiente comando, sustituyendo `INTERFACE_NAME` y `CONNECTION_NAME` por sus propios valores. + +En nuestro ejemplo, hemos denominado nuestro perfil de configuración «private-interface». + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Ejemplo:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Compruebe que la interfaz se ha conectado correctamente: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Una vez hecho esto, se creará un nuevo archivo de configuración denominado *xxxxxxxxx.nmconnection* en la carpeta `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Puede editar este fichero utilizando el gestor `nmcli`, sustituyendo `IP_ADDRESS`, `PREFIX` y `CONNECTION_NAME` por sus propios valores. + +- Añada su IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Ejemplo:** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Cambie la configuración de **auto** a **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Ejemplo:** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Hacer persistente la configuración: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Ejemplo:** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Reinicie su red con el siguiente comando: + +```bash +sudo systemctl restart NetworkManager +``` + #### Configuración Windows A modo de ejemplo, las siguientes configuraciones utilizarán el rango de direcciones IP de `192.168.0.0/16` (**Máscara de subred**: `255.255.0.0`). diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-us.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-us.md index 832e997d9ff..5b2ed88ca4f 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-us.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.es-us.md @@ -1,13 +1,9 @@ --- title: 'Configurar varios servidores dedicados en el vRack' excerpt: 'Cómo configurar varios servidores dedicados en el vRack' -updated: 2024-10-17 +updated: 2025-03-24 --- -> [!primary] -> Esta traducción ha sido generada de forma automática por nuestro partner SYSTRAN. En algunos casos puede contener términos imprecisos, como en las etiquetas de los botones o los detalles técnicos. En caso de duda, le recomendamos que consulte la versión inglesa o francesa de la guía. Si quiere ayudarnos a mejorar esta traducción, por favor, utilice el botón «Contribuir» de esta página. -> - ## Objetivo El vRack (rack virtual) de OVHcloud permite agrupar virtualmente varios servidores (independientemente de su número y su ubicación física en nuestros datacenters) y conectarlos a un switch virtual dentro de una misma red privada. De este modo, sus servidores pueden comunicarse entre sí de forma privada y segura, dentro de una VLAN dedicada. @@ -60,9 +56,9 @@ Por ejemplo, los siguientes detalles de configuración tendrán la dirección IP Puede utilizar cualquier rango de IP privadas de su elección y cualquier dirección dentro de este rango. > -#### Configuraciones GNU/Linux +#### Identificación de la interfaz vRack -Los nombres de las interfaces de red de los servidores no son siempre los mismos. En los siguientes ejemplos, sustituya NETWORK_INTERFACE por el nombre de interfaz apropiado. +Los nombres de las interfaces de red de los servidores no son siempre los mismos. La mejor forma de comprobar la interfaz del vRack es comprobar la pestaña `Interfaces de red`{.action} del servidor en el [Panel de configuración de OVHcloud](/links/manager). En la tabla inferior, tenga en cuenta la dirección MAC, que es también el **Nombre** de la interfaz **privada**. @@ -80,24 +76,30 @@ En la línea que empieza por ```link ether```, puede comprobar que esta interfaz link ether f0:00:00:ef:0e:f0 ``` +#### Configuraciones GNU/Linux + ##### **Debian 12** Utilice el editor de texto que desee para editar el archivo de configuración de red situado en `/etc/netplan/`. El archivo se llama `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Añada la configuración IP a la configuración existente después de la línea `ethernets`: +Añada las siguientes líneas a la configuración existente después de la línea `version: 2`. Sustituya `NETWORK_INTERFACE` y `IP_ADDRESS/PREFIX` por sus propios valores. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Ejemplo:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Es importante respetar la alineación de cada elemento en los archivos `yaml` como se muestra en el ejemplo anterior. No use la tecla de tabulación para crear el espacio. Sólo se debe utilizar la tecla espacio. @@ -108,7 +110,7 @@ Guarde los cambios en el archivo de configuración y salga del editor. Aplique la configuración: ```bash -netplan apply +sudo netplan apply ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. @@ -118,24 +120,28 @@ Repita este procedimiento para los demás servidores y asígnele a cada uno de e En un editor de texto, abra el archivo de configuración de red en `/etc/network/interfaces.d` para cambiarlo. El archivo se llama `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Añada las siguientes líneas: +Añada las siguientes líneas a la configuración existente, sustituya `NETWORK_INTERFACE`, `IP_ADDRESS` y `NETMASK` por sus propios valores: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Ejemplo:** + +![debian config](images/debian_configuration.png){.thumbnail} + Guarde los cambios en el archivo de configuración y salga del editor. Reinicie el servicio de red para aplicar la configuración: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. @@ -145,19 +151,23 @@ Repita este procedimiento para los demás servidores y asígnele a cada uno de e Utilice el editor de texto que desee para editar el archivo de configuración de red situado en `/etc/netplan/`. El archivo se llama `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Añada la configuración IP a la configuración existente después de la línea `ethernets`: +Añada las siguientes líneas a la configuración existente después de la línea `version: 2`. Sustituya `NETWORK_INTERFACE` y `IP_ADDRESS/PREFIX` por sus propios valores. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Ejemplo:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Es importante respetar la alineación de cada elemento en los archivos `yaml` como se muestra en el ejemplo anterior. No use la tecla de tabulación para crear el espacio. Sólo se debe utilizar la tecla espacio. @@ -168,46 +178,144 @@ Guarde los cambios en el archivo de configuración y salga del editor. Aplique la configuración: ```bash -netplan apply +sudo netplan apply ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. -##### **CentOS** +##### **CentOS, AlmaLinux y RockyLinux** -Utilice el editor de texto que desee para abrir el archivo `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Una vez que haya identificado la interfaz de red privada, utilice el editor de texto que desee para crear el siguiente archivo de configuración de red. Sustituya `NETWORK_INTERFACE` por su propio valor. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Añadir estas líneas: +Añada estas líneas, sustituyendo `NETWORK_INTERFACE`, `IP_ADDRESS` y `NETMASK` por sus propios valores: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Ejemplo:** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Guarde los cambios en el archivo de configuración y salga del editor. Reinicie el servicio de red para aplicar los cambios: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -En **CentOS 8**, utilice el siguiente comando: +En **CentOS 8, AlmaLinux y RockyLinux** utilice el siguiente comando: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repita este procedimiento para los demás servidores y asígnele a cada uno de ellos una dirección IP no utilizada desde su rango privado. A continuación, los servidores podrán comunicarse entre sí en la red privada. +##### Fedora + +Una vez que haya identificado el nombre de su interfaz privada (como se explica [aquí](#vrack-interface)), ejecute el siguiente comando para comprobar que esté conectada. En nuestro ejemplo, nuestra interfaz se denomina `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Si el `STATE` del `DEVICE` aparece como `disconnected`, es necesario conectarlo antes de configurar la IP. + +Al añadir una conexión **ethernet**, es necesario crear un perfil de configuración y asignarlo a un dispositivo. + +Ejecute el siguiente comando, sustituyendo `INTERFACE_NAME` y `CONNECTION_NAME` por sus propios valores. + +En nuestro ejemplo, hemos denominado nuestro perfil de configuración «private-interface». + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Ejemplo:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Compruebe que la interfaz se ha conectado correctamente: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Una vez hecho esto, se creará un nuevo archivo de configuración denominado *xxxxxxxxx.nmconnection* en la carpeta `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Puede editar este fichero utilizando el gestor `nmcli`, sustituyendo `IP_ADDRESS`, `PREFIX` y `CONNECTION_NAME` por sus propios valores. + +- Añada su IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Ejemplo:** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Cambie la configuración de **auto** a **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Ejemplo:** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Hacer persistente la configuración: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Ejemplo:** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Reinicie su red con el siguiente comando: + +```bash +sudo systemctl restart NetworkManager +``` + #### Configuración Windows A modo de ejemplo, las siguientes configuraciones utilizarán el rango de direcciones IP de `192.168.0.0/16` (**Máscara de subred**: `255.255.0.0`). @@ -250,4 +358,4 @@ Repita este procedimiento para los demás servidores y asígnele a cada uno de e [Crear varias VLAN en el vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack). -Interactúe con nuestra comunidad de usuarios en . +Interactúe con nuestra comunidad de usuarios en . \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-ca.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-ca.md index 33d8f5dff2f..4ae7fd10491 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-ca.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-ca.md @@ -1,7 +1,7 @@ --- title: 'Configurer le vRack sur vos serveurs dédiés' excerpt: 'Découvrez comment configurer le vRack sur plusieurs serveurs dédiés' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objectif @@ -56,9 +56,9 @@ Par exemple, les détails de configuration ci-dessous auront l'adresse IP `192.1 Vous pouvez utiliser n'importe quelle plage d'IP privée de votre choix et n'importe quelle adresse dans cette plage. > -#### Configurations GNU/Linux +#### Identification de l’interface vRack -Les noms des interfaces réseau de vos serveurs ne sont pas toujours les mêmes. Dans les exemples suivants, remplacez NETWORK_INTERFACE par le nom d'interface approprié. +Les noms des interfaces réseau de vos serveurs ne sont pas toujours les mêmes. Le meilleur moyen de vérifier la bonne interface pour le vRack est de vérifier l'onglet `Interfaces réseau`{.action} de votre serveur dans votre [espace client OVHcloud](/links/manager). Dans le tableau du bas, notez l'adresse MAC qui est aussi le **Nom** de l'interface **Privée**. @@ -70,30 +70,36 @@ Une fois connecté à votre serveur via SSH, vous pouvez lister vos interfaces r ip a ``` -Sur la ligne qui commence par ```link ether```, vous pouvez vérifier que cette interface correspond à l'interface **Privée** renseignée dans votre [espace client OVHcloud](/links/manager). Utilisez ce nom d'interface pour remplacer `NETWORK_INTERFACE` dans les configurations ci-dessous (exemple : `eno2`). +Sur la ligne qui commence par ```link ether```, vous pouvez vérifier que cette interface correspond à l'interface **Privée** renseignée dans votre [espace client OVHcloud](/links/manager). Utilisez ce nom d'interface pour remplacer `NETWORK_INTERFACE` dans les configurations ci-dessous (exemple : `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +#### Configurations GNU/Linux + ##### **Debian 12** A l'aide de l'éditeur de texte de votre choix, ouvrez le fichier de configuration réseau se trouvant dans `/etc/netplan/` afin de l'éditer. Ici, le fichier s'appelle `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Ajoutez la configuration IP à la configuration existante après la ligne `ethernets` : +Ajoutez les lignes suivantes à la configuration existante après la ligne `version: 2`. Remplacez `NETWORK_INTERFACE` et `IP_ADDRESS/PREFIX` par vos propres valeurs. ```yaml ethernets: - NETWORK_INTERFACE : - dhcp4: no + NETWORK_INTERFACE: + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Exemple :** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Il est important de respecter l'alignement de chaque élément dans les fichiers `yaml` comme représenté dans l'exemple ci-dessus. N'utilisez pas la touche de tabulation pour créer votre espacement. Seule la touche espace doit être utilisée. @@ -104,7 +110,7 @@ Enregistrez vos modifications dans le fichier de configuration et quittez l'édi Appliquez la configuration : ```bash -netplan apply +sudo netplan apply ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. @@ -114,24 +120,28 @@ Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'ent Dans un éditeur de texte, ouvrez le fichier de configuration réseau situé dans `/etc/network/interfaces.d` pour le modifier. Ici, le fichier s'appelle `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Ajoutez les lignes suivantes : +Ajoutez les lignes suivantes à la configuration existante, remplacez `NETWORK_INTERFACE`, `IP_ADDRESS` et `NETMASK` par vos propres valeurs : ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Exemple :** + +![debian config](images/debian_configuration.png){.thumbnail} + Enregistrez vos modifications dans le fichier de configuration et quittez l'éditeur. Redémarrez le service réseau pour appliquer la configuration : ```bash -systemctl restart networking +sudo systemctl restart networking ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. @@ -141,19 +151,23 @@ Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'ent A l'aide de l'éditeur de texte de votre choix, ouvrez le fichier de configuration réseau se trouvant dans `/etc/netplan/` afin de l'éditer. Ici, le fichier s'appelle `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Ajoutez la configuration IP à la configuration existante après la ligne `ethernets` : +Ajoutez les lignes suivantes à la configuration existante après la ligne `version: 2`. Remplacez `NETWORK_INTERFACE` et `IP_ADDRESS/PREFIX` par vos propres valeurs. ```yaml ethernets: - NETWORK_INTERFACE : - dhcp4: no + NETWORK_INTERFACE: + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Exemple :** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Il est important de respecter l'alignement de chaque élément dans les fichiers `yaml` comme représenté dans l'exemple ci-dessus. N'utilisez pas la touche de tabulation pour créer votre espacement. Seule la touche espace doit être utilisée. @@ -164,46 +178,144 @@ Enregistrez vos modifications dans le fichier de configuration et quittez l'édi Appliquez la configuration : ```bash -netplan apply +sudo netplan apply ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. -##### **CentOS** +##### **CentOS, AlmaLinux et RockyLinux** -A l'aide de l'éditeur de texte de votre choix, ouvrez le fichier `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Une fois que vous avez identifié votre interface de réseau privé, utilisez l'éditeur de texte de votre choix pour créer le fichier de configuration réseau suivant. Remplacez `NETWORK_INTERFACE` par votre propre valeur. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Ajouter ces lignes : +Ajoutez ces lignes, en remplaçant `NETWORK_INTERFACE`, `IP_ADDRESS` et `NETMASK` par vos propres valeurs : ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Exemple :** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Enregistrez vos modifications dans le fichier de configuration et quittez l'éditeur. Redémarrez le service réseau pour appliquer les modifications : ```bash -systemctl restart networking +sudo systemctl restart networking ``` -Sous **CentOS 8**, utilisez cette commande : +Sous **CentOS 8, AlmaLinux et RockyLinux**, utilisez cette commande : ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. +##### Fedora + +Une fois que vous avez identifié le nom de votre interface privée (comme expliqué [ici](#vrack-interface)), lancez la commande suivante pour vérifiez qu'elle est bien connectée. Dans notre exemple, notre interface est appelée `eno2` : + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Si le `STATE` du `DEVICE` apparaît comme `disconnected`, il est nécessaire de le connecter avant de configurer l'IP. + +Lors de l'ajout d'une connexion **ethernet**, nous devons créer un profil de configuration que nous assignons ensuite à un périphérique. + +Exécutez la commande suivante, en remplaçant `INTERFACE_NAME` et `CONNECTION_NAME` par vos propres valeurs. + +Dans notre exemple, nous avons nommé notre profil de configuration `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Exemple :** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Vérifiez que l'interface a été correctement connectée : + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Une fois cela fait, un nouveau fichier de configuration nommé *xxxxxxxxxx.nmconnection* sera créé dans le dossier `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Vous pouvez alors éditer ce fichier en utilisant le gestionnaire `nmcli`, en remplaçant `IP_ADDRESS`, `PREFIX` et `CONNECTION_NAME` par vos propres valeurs. + +- Ajoutez votre IP : + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Exemple :** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Changez la configuration de **auto** à **manual** : + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Exemple :** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Rendez la configuration persistante : + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Exemple :** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Redémarrez votre réseau avec la commande suivante : + +```bash +sudo systemctl restart NetworkManager +``` + #### Configuration Windows À titre d'exemple, les configurations suivantes utiliseront la plage d'adresses IP de `192.168.0.0/16` (**Masque de sous-réseau**: `255.255.0.0`). @@ -246,4 +358,4 @@ Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'ent [Créer plusieurs VLAN dans le vRack](/pages/bare_metal_cloud/dedicated_servers/creating-multiple-vlans-in-a-vrack). -Échangez avec notre [communauté d'utilisateurs](/links/community). +Échangez avec notre [communauté d'utilisateurs](/links/community). \ No newline at end of file diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-fr.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-fr.md index 33d8f5dff2f..fa8950b8477 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-fr.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.fr-fr.md @@ -1,7 +1,7 @@ --- title: 'Configurer le vRack sur vos serveurs dédiés' excerpt: 'Découvrez comment configurer le vRack sur plusieurs serveurs dédiés' -updated: 2024-10-17 +updated: 2025-03-24 --- ## Objectif @@ -56,9 +56,9 @@ Par exemple, les détails de configuration ci-dessous auront l'adresse IP `192.1 Vous pouvez utiliser n'importe quelle plage d'IP privée de votre choix et n'importe quelle adresse dans cette plage. > -#### Configurations GNU/Linux +#### Identification de l’interface vRack -Les noms des interfaces réseau de vos serveurs ne sont pas toujours les mêmes. Dans les exemples suivants, remplacez NETWORK_INTERFACE par le nom d'interface approprié. +Les noms des interfaces réseau de vos serveurs ne sont pas toujours les mêmes. Le meilleur moyen de vérifier la bonne interface pour le vRack est de vérifier l'onglet `Interfaces réseau`{.action} de votre serveur dans votre [espace client OVHcloud](/links/manager). Dans le tableau du bas, notez l'adresse MAC qui est aussi le **Nom** de l'interface **Privée**. @@ -70,30 +70,36 @@ Une fois connecté à votre serveur via SSH, vous pouvez lister vos interfaces r ip a ``` -Sur la ligne qui commence par ```link ether```, vous pouvez vérifier que cette interface correspond à l'interface **Privée** renseignée dans votre [espace client OVHcloud](/links/manager). Utilisez ce nom d'interface pour remplacer `NETWORK_INTERFACE` dans les configurations ci-dessous (exemple : `eno2`). +Sur la ligne qui commence par ```link ether```, vous pouvez vérifier que cette interface correspond à l'interface **Privée** renseignée dans votre [espace client OVHcloud](/links/manager). Utilisez ce nom d'interface pour remplacer `NETWORK_INTERFACE` dans les configurations ci-dessous (exemple : `eth1`). ```console link ether f0:00:00:ef:0e:f0 ``` +#### Configurations GNU/Linux + ##### **Debian 12** A l'aide de l'éditeur de texte de votre choix, ouvrez le fichier de configuration réseau se trouvant dans `/etc/netplan/` afin de l'éditer. Ici, le fichier s'appelle `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Ajoutez la configuration IP à la configuration existante après la ligne `ethernets` : +Ajoutez les lignes suivantes à la configuration existante après la ligne `version: 2`. Remplacez `NETWORK_INTERFACE` et `IP_ADDRESS/PREFIX` par vos propres valeurs. ```yaml ethernets: - NETWORK_INTERFACE : - dhcp4: no + NETWORK_INTERFACE: + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Exemple :** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Il est important de respecter l'alignement de chaque élément dans les fichiers `yaml` comme représenté dans l'exemple ci-dessus. N'utilisez pas la touche de tabulation pour créer votre espacement. Seule la touche espace doit être utilisée. @@ -104,7 +110,7 @@ Enregistrez vos modifications dans le fichier de configuration et quittez l'édi Appliquez la configuration : ```bash -netplan apply +sudo netplan apply ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. @@ -114,24 +120,28 @@ Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'ent Dans un éditeur de texte, ouvrez le fichier de configuration réseau situé dans `/etc/network/interfaces.d` pour le modifier. Ici, le fichier s'appelle `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Ajoutez les lignes suivantes : +Ajoutez les lignes suivantes à la configuration existante, remplacez `NETWORK_INTERFACE`, `IP_ADDRESS` et `NETMASK` par vos propres valeurs : ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Exemple :** + +![debian config](images/debian_configuration.png){.thumbnail} + Enregistrez vos modifications dans le fichier de configuration et quittez l'éditeur. Redémarrez le service réseau pour appliquer la configuration : ```bash -systemctl restart networking +sudo systemctl restart networking ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. @@ -141,19 +151,23 @@ Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'ent A l'aide de l'éditeur de texte de votre choix, ouvrez le fichier de configuration réseau se trouvant dans `/etc/netplan/` afin de l'éditer. Ici, le fichier s'appelle `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Ajoutez la configuration IP à la configuration existante après la ligne `ethernets` : +Ajoutez les lignes suivantes à la configuration existante après la ligne `version: 2`. Remplacez `NETWORK_INTERFACE` et `IP_ADDRESS/PREFIX` par vos propres valeurs. ```yaml ethernets: - NETWORK_INTERFACE : - dhcp4: no + NETWORK_INTERFACE: + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Exemple :** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Il est important de respecter l'alignement de chaque élément dans les fichiers `yaml` comme représenté dans l'exemple ci-dessus. N'utilisez pas la touche de tabulation pour créer votre espacement. Seule la touche espace doit être utilisée. @@ -164,46 +178,144 @@ Enregistrez vos modifications dans le fichier de configuration et quittez l'édi Appliquez la configuration : ```bash -netplan apply +sudo netplan apply ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. -##### **CentOS** +##### **CentOS, AlmaLinux et RockyLinux** -A l'aide de l'éditeur de texte de votre choix, ouvrez le fichier `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Une fois que vous avez identifié votre interface de réseau privé, utilisez l'éditeur de texte de votre choix pour créer le fichier de configuration réseau suivant. Remplacez `NETWORK_INTERFACE` par votre propre valeur. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Ajouter ces lignes : +Ajoutez ces lignes, en remplaçant `NETWORK_INTERFACE`, `IP_ADDRESS` et `NETMASK` par vos propres valeurs : ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Exemple :** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Enregistrez vos modifications dans le fichier de configuration et quittez l'éditeur. Redémarrez le service réseau pour appliquer les modifications : ```bash -systemctl restart networking +sudo systemctl restart networking ``` -Sous **CentOS 8**, utilisez cette commande : +Sous **CentOS 8, AlmaLinux et RockyLinux**, utilisez cette commande : ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Répétez cette procédure pour vos autres serveurs et attribuez à chacun d'entre eux une adresse IP inutilisée à partir de votre plage privée. Dès lors, vos serveurs pourront communiquer entre eux sur le réseau privé. +##### Fedora + +Une fois que vous avez identifié le nom de votre interface privée (comme expliqué [ici](#vrack-interface)), lancez la commande suivante pour vérifiez qu'elle est bien connectée. Dans notre exemple, notre interface est appelée `eno2` : + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Si le `STATE` du `DEVICE` apparaît comme `disconnected`, il est nécessaire de le connecter avant de configurer l'IP. + +Lors de l'ajout d'une connexion **ethernet**, nous devons créer un profil de configuration que nous assignons ensuite à un périphérique. + +Exécutez la commande suivante, en remplaçant `INTERFACE_NAME` et `CONNECTION_NAME` par vos propres valeurs. + +Dans notre exemple, nous avons nommé notre profil de configuration `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Exemple :** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Vérifiez que l'interface a été correctement connectée : + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Une fois cela fait, un nouveau fichier de configuration nommé *xxxxxxxxxx.nmconnection* sera créé dans le dossier `/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Vous pouvez alors éditer ce fichier en utilisant le gestionnaire `nmcli`, en remplaçant `IP_ADDRESS`, `PREFIX` et `CONNECTION_NAME` par vos propres valeurs. + +- Ajoutez votre IP : + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Exemple :** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Changez la configuration de **auto** à **manual** : + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Exemple :** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Rendez la configuration persistante : + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Exemple :** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Redémarrez votre réseau avec la commande suivante : + +```bash +sudo systemctl restart NetworkManager +``` + #### Configuration Windows À titre d'exemple, les configurations suivantes utiliseront la plage d'adresses IP de `192.168.0.0/16` (**Masque de sous-réseau**: `255.255.0.0`). diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.it-it.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.it-it.md index 88f1264c7ab..3e1e235229d 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.it-it.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.it-it.md @@ -1,13 +1,9 @@ --- title: 'Configurare due o più server dedicati nella vRack' excerpt: 'Scopri come configurare due o più server dedicati nella vRack' -updated: 2024-10-17 +updated: 2025-03-24 --- -> [!primary] -> Questa traduzione è stata generata automaticamente dal nostro partner SYSTRAN. I contenuti potrebbero presentare imprecisioni, ad esempio la nomenclatura dei pulsanti o alcuni dettagli tecnici. In caso di dubbi consigliamo di fare riferimento alla versione inglese o francese della guida. Per aiutarci a migliorare questa traduzione, utilizza il pulsante "Contribuisci" di questa pagina. -> - ## Obiettivo La vRack (rack virtuale) OVHcloud permette di unire virtualmente diversi server (indipendentemente dal loro numero e dalla loro localizzazione fisica nei nostri datacenter) e di connetterli a uno switch virtuale all'interno della stessa rete privata. In questo modo i server possono comunicare in modo privato e sicuro tra loro, all'interno di una VLAN dedicata. @@ -60,9 +56,9 @@ Ad esempio, i dettagli della configurazione qui sotto avranno l'indirizzo IP `19 Puoi utilizzare qualsiasi gamma di IP privati di tua scelta e qualsiasi indirizzo in questa gamma. > -#### Configurazioni GNU/Linux +#### Identificazione dell'interfaccia vRack -I nomi delle interfacce di rete dei tuoi server non sono sempre gli stessi. Nei seguenti esempi, sostituisci NETWORK_INTERFACE con il nome di interfaccia appropriato. +I nomi delle interfacce di rete dei tuoi server non sono sempre gli stessi. Per verificare la corretta interfaccia della vRack è necessario verificare la scheda `Interfacce di rete`{.action} del server nello [Spazio Cliente OVHcloud](/links/manager). Nella tabella in basso, indica l'indirizzo MAC, che è anche il **Nome** dell'interfaccia **Privata**. @@ -80,24 +76,31 @@ Sulla linea che inizia con ```link ether```, verifica che questa interfaccia cor link ether f0:00:00:ef:0e:f0 ``` +#### Configurazioni GNU/Linux + ##### **Debian 12** Utilizza il editor di testo scelto per aprire il file di configurazione di rete all'interno `/etc/netplan/`per modificarlo. Il file si chiama `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Aggiungi la configurazione IP alla configurazione esistente dopo la linea `ethernet`: +Aggiungere le righe seguenti alla configurazione esistente dopo la riga `version: 2`. Sostituisci `NETWORK_INTERFACE` e `IP_ADDRESS/PREFIX` con i tuoi valori. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Esempio:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + + > [!warning] > > È importante rispettare l'allineamento di ciascun elemento nei file `yaml`, come indicato nell'esempio di cui sopra. Non utilizzare il tasto di tabulazione per creare la tua spaziatura. Deve essere utilizzato solo il tasto spazio. @@ -108,7 +111,7 @@ Salva le modifiche nel file di configurazione e lascia l'editor. Applica la configurazione: ```bash -netplan apply +sudo netplan apply ``` Ripeti questa procedura per gli altri server e attribuisci a ciascuno di essi un indirizzo IP non utilizzato a partire dalla tua gamma privata. Da questo momento, i tuoi server potranno comunicare tra loro sulla rete privata. @@ -118,24 +121,28 @@ Ripeti questa procedura per gli altri server e attribuisci a ciascuno di essi un In un editor di testo, apri il file di configurazione di rete all'indirizzo `/etc/network/interfaces.d` per modificarlo. Il file si chiama `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Aggiungi queste righe: +Aggiungere le righe seguenti alla configurazione esistente dopo la riga `version: 2`. Sostituisci `NETWORK_INTERFACE` e `IP_ADDRESS/PREFIX` con i tuoi valori. ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Esempio:** + +![debian config](images/debian_configuration.png){.thumbnail} + Salva le modifiche nel file di configurazione e lascia l'editor. Riavvia il servizio di rete per applicare la configurazione: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Ripeti questa procedura per gli altri server e attribuisci a ciascuno di essi un indirizzo IP non utilizzato a partire dalla tua gamma privata. Da questo momento, i tuoi server potranno comunicare tra loro sulla rete privata. @@ -145,19 +152,21 @@ Ripeti questa procedura per gli altri server e attribuisci a ciascuno di essi un Utilizza il editor di testo scelto per aprire il file di configurazione di rete all'interno `/etc/netplan/`per modificarlo. Il file si chiama `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Aggiungi la configurazione IP alla configurazione esistente dopo la linea `ethernet`: +Aggiungere le righe seguenti alla configurazione esistente dopo la riga `version: 2`. Sostituisci `NETWORK_INTERFACE` e `IP_ADDRESS/PREFIX` con i tuoi valori. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Esempio:** + > [!warning] > > È importante rispettare l'allineamento di ciascun elemento nei file `yaml`, come indicato nell'esempio di cui sopra. Non utilizzare il tasto di tabulazione per creare la tua spaziatura. Deve essere utilizzato solo il tasto spazio. @@ -168,46 +177,146 @@ Salva le modifiche nel file di configurazione e lascia l'editor. Applica la configurazione: ```bash -netplan apply +sudo netplan apply ``` Ripeti questa procedura per gli altri server e attribuisci a ciascuno di essi un indirizzo IP non utilizzato a partire dalla tua gamma privata. Da questo momento, i tuoi server potranno comunicare tra loro sulla rete privata. -##### **CentOS** +##### **CentOS, AlmaLinux e RockyLinux** -Con l'editor di testo scelto, apri il file `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Dopo aver identificato l'interfaccia di rete privata, utilizzare l'editor di testo desiderato per creare il seguente file di configurazione di rete. Sostituisci `NETWORK_INTERFACE` con il tuo valore. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Aggiungi queste linee: +Aggiungi queste righe alla configurazione esistente, sostituisci `NETWORK_INTERFACE`, `IP_ADDRESS` e `NETMASK` con i tuoi valori: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Esempio:** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Salva le modifiche nel file di configurazione e lascia l'editor. Riavvia il servizio di rete per applicare le modifiche: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -Con **CentOS 8**, esegui questo comando: +Con **CentOS 8, AlmaLinux e RockyLinux**, esegui questo comando: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Ripeti questa procedura per gli altri server e attribuisci a ciascuno di essi un indirizzo IP non utilizzato a partire dalla tua gamma privata. Da questo momento, i tuoi server potranno comunicare tra loro sulla rete privata. +##### Fedora + +Una volta identificato il nome dell’interfaccia privata (come spiegato [qui](#vrack-interface)), esegui il comando seguente per verificare che sia connessa. Nel nostro esempio, la nostra interfaccia è chiamata `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Se il `STATE` del `DEVICE` appare come `disconnected`, è necessario connetterlo prima di configurare l’IP. + +Quando si aggiunge una connessione **ethernet**, è necessario creare un profilo di configurazione da assegnare a un dispositivo. + +Eseguire il comando seguente, sostituendo `INTERFACE_NAME` e `CONNECTION_NAME` con i propri valori. + +Nel nostro esempio, abbiamo nominato il nostro profilo di configurazione `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Esempio:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Verifica che l’interfaccia sia stata connessa correttamente: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +A questo punto, nella cartella `/etc/NetworkManager/system-connections` verrà creato un nuovo file di configurazione denominato *xxxxxxxxxx.nmconnection*. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +A questo punto, è possibile modificare il file utilizzando il gestore `nmcli`, sostituendo `IP_ADDRESS`, `PREFIX` e `CONNECTION_NAME` con i propri valori. + +- Aggiungi il tuo IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Esempio:** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +**Esempio:** + +- Modifica la configurazione da **auto** a **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Esempio:** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Rendi persistente la configurazione: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Esempio:** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Riavvia la tua rete con questo comando: + +```bash +sudo systemctl restart NetworkManager +``` + #### Configurazione Windows Ad esempio, queste configurazioni utilizzeranno la classe di indirizzi IP di `192.168.0.0/16` (**Maschera di sottorete**: `255.255.0.0`). diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pl-pl.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pl-pl.md index bcb03b8c74e..dda0b327efd 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pl-pl.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pl-pl.md @@ -1,13 +1,9 @@ --- title: 'Konfiguracja kilku serwerów dedykowanych w sieci vRack' excerpt: 'Dowiedz się, jak połączyć kilka serwerów w ramach rozwiązania vRack' -updated: 2024-10-17 +updated: 2025-03-24 --- -> [!primary] -> Tłumaczenie zostało wygenerowane automatycznie przez system naszego partnera SYSTRAN. W niektórych przypadkach mogą wystąpić nieprecyzyjne sformułowania, na przykład w tłumaczeniu nazw przycisków lub szczegółów technicznych. W przypadku jakichkolwiek wątpliwości zalecamy zapoznanie się z angielską/francuską wersją przewodnika. Jeśli chcesz przyczynić się do ulepszenia tłumaczenia, kliknij przycisk "Zgłóś propozycję modyfikacji" na tej stronie. -> - ## Wprowadzenie vRack (wirtualna szafa) OVHcloud pozwala na wirtualne zebranie kilku serwerów (bez względu na ich liczbę i ich fizyczną lokalizację w naszych centrach danych) i na ich podłączenie do wirtualnego switcha w ramach tej samej prywatnej sieci. Dzięki temu Twoje serwery mogą komunikować się między sobą w ramach prywatnej i zabezpieczonej sieci VLAN. @@ -60,9 +56,9 @@ Na przykład poniższe szczegóły konfiguracji będą miały adres IP `192.168. Możesz korzystać z dowolnego zakresu prywatnych adresów IP i dowolnych adresów w tym zakresie. > -#### Konfiguracja GNU/Linux +#### Identyfikacja interfejsu vRack -Nazwy interfejsów sieciowych serwerów nie zawsze są takie same. W poniższych przykładach zastąp NETWORK_INTERFACE odpowiednią nazwą interfejsu. +Nazwy interfejsów sieciowych serwerów nie zawsze są takie same. Najlepszym sposobem, aby sprawdzić poprawny interfejs dla usługi vRack jest sprawdzenie karty `Interfejsy sieciowe`{.action} Twojego serwera w Twoim [Panelu klienta OVHcloud](/links/manager). W dolnej tabeli kliknij adres MAC, który jest również **Nazwa** interfejsu **Prywatnego**. @@ -80,24 +76,30 @@ W wierszu, który rozpoczyna się od ```link ether```, możesz sprawdzić, czy i link ether f0:00:00:ef:0e:f0 ``` +#### Konfiguracja GNU/Linux + ##### **Debian 12** -Aby go edytować, otwórz plik konfiguracyjny sieci w `/etc/netplan/`. Ten plik nazywa się `50-cloud-init.yaml`. +Aby edytować plik, otwórz plik konfiguracyjny sieci w katalogu `/etc/netplan/` przy użyciu wybranego edytora tekstu. Plik nosi nazwę `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Dodaj konfigurację IP do istniejącej konfiguracji po linii `ethernets`: +Dodaj następujące linie do istniejącej konfiguracji po linii `version: 2`. Zastąp `NETWORK_INTERFACE` oraz `IP_ADDRESS/PREFIX` własnymi wartościami. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Przykład:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Ważne jest, aby zachować wyrównanie każdego elementu w plikach `yaml` jak pokazano w powyższym przykładzie. Nie używaj przycisku tabulacji do tworzenia odstępów. Należy używać tylko klawisza spacji. @@ -108,7 +110,7 @@ Zapisz zmiany w pliku konfiguracyjnym i zamknij edytor. Zastosuj konfigurację: ```bash -netplan apply +sudo netplan apply ``` Powtórz tę procedurę dla innych serwerów i przypisz każdemu z nich nieużywany adres IP z Twojego zakresu prywatnego. Twoje serwery będą mogły komunikować się między sobą w sieci prywatnej. @@ -118,46 +120,54 @@ Powtórz tę procedurę dla innych serwerów i przypisz każdemu z nich nieużyw W edytorze tekstu otwórz plik konfiguracyjny sieci znajdujący się w `/etc/network/interfaces.d`, aby go zmienić. Tutaj plik nazywa się `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Dodaj następujące wiersze: +Dodaj następujące wiersze do istniejącej konfiguracji, zmień `NETWORK_INTERFACE`, `IP_ADDRESS` oraz `NETMASK` na własne wartości: ```console auto NETWORK_INTERFACE iface NETWORK_INTERFACE inet static -address 192.168.0.1 -netmask 255.255.0.0 + address IP_ADDRESS + netmask NETMASK ``` +**Przykład:** + +![debian config](images/debian_configuration.png){.thumbnail} + Zapisz zmiany w pliku konfiguracyjnym i zamknij edytor. Zrestartuj usługę sieciową, aby zastosować konfigurację: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Powtórz tę procedurę dla innych serwerów i przypisz każdemu z nich nieużywany adres IP z Twojego zakresu prywatnego. Twoje serwery będą mogły komunikować się między sobą w sieci prywatnej. ##### **Ubuntu** -Aby go edytować, otwórz plik konfiguracyjny sieci w `/etc/netplan/`. Ten plik nazywa się `50-cloud-init.yaml`. +Aby edytować plik, otwórz plik konfiguracyjny sieci w katalogu `/etc/netplan/` przy użyciu wybranego edytora tekstu. Plik nosi nazwę `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Dodaj konfigurację IP do istniejącej konfiguracji po linii `ethernets`: +Dodaj następujące linie do istniejącej konfiguracji po linii `version: 2`. Zastąp `NETWORK_INTERFACE` oraz `IP_ADDRESS/PREFIX` własnymi wartościami. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Przykład:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > Ważne jest, aby zachować wyrównanie każdego elementu w plikach `yaml` jak pokazano w powyższym przykładzie. Nie używaj przycisku tabulacji do tworzenia odstępów. Należy używać tylko klawisza spacji. @@ -168,46 +178,144 @@ Zapisz zmiany w pliku konfiguracyjnym i zamknij edytor. Zastosuj konfigurację: ```bash -netplan apply +sudo netplan apply ``` Powtórz tę procedurę dla innych serwerów i przypisz każdemu z nich nieużywany adres IP z Twojego zakresu prywatnego. Twoje serwery będą mogły komunikować się między sobą w sieci prywatnej. -##### **CentOS** +##### **CentOS, AlmaLinux i RockyLinux** -Za pomocą wybranego edytora tekstu otwórz plik `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Po zidentyfikowaniu interfejsu sieci prywatnej utwórz następujący plik konfiguracyjny sieci, używając wybranego edytora tekstu. Zastąp `NETWORK_INTERFACE` swoją własną wartością. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Dodaj te linie: +Dodaj następujące wiersze do istniejącej konfiguracji, zmień `NETWORK_INTERFACE`, `IP_ADDRESS` oraz `NETMASK` na własne wartości: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Przykład:** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Zapisz zmiany w pliku konfiguracyjnym i zamknij edytor. Zrestartuj usługę sieciową, aby wprowadzić zmiany: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -W systemie **CentOS 8** należy użyć tego polecenia: +W systemie **CentOS 8, AlmaLinux i RockyLinux** należy użyć tego polecenia: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Powtórz tę procedurę dla innych serwerów i przypisz każdemu z nich nieużywany adres IP z Twojego zakresu prywatnego. Twoje serwery będą mogły komunikować się między sobą w sieci prywatnej. +##### Fedora + +Po określeniu nazwy interfejsu prywatnego (zgodnie z wyjaśnieniami [tutaj](#vrack-interface)), wprowadź następujące polecenie, aby upewnić się, że interfejs jest poprawnie podłączony. W naszym przykładzie nasz interfejs nosi nazwę `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Jeśli `STATE` dla `DEVICE` wyświetla się jako `disconnected`, należy podłączyć go przed skonfigurowaniem IP. + +Podczas dodawania połączenia **ethernet** musimy utworzyć profil konfiguracji, który następnie przypiszemy do urządzenia. + +Wprowadź następującą komendę, zastępując polecenia `INTERFACE_NAME` oraz `CONNECTION_NAME` Twoimi wartościami. + +W naszym przykładzie nazwaliśmy nasz profil konfiguracji `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Przykład:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Upewnij się, że interfejs został prawidłowo podłączony: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +W wyniku tej operacji nowy plik konfiguracyjny o nazwie *xxxxxxxxxx.nmconnection* zostanie utworzony w folderze`/etc/NetworkManager/system-connections`. + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Możesz edytować ten plik za pomocą managera `nmcli`, zastępując `IP_ADDRESS`, `PREFIX` oraz `CONNECTION_NAME` własnymi wartościami. + +- Dodaj IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Przykład:** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Zmień konfigurację z **auto** na **manual**: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Przykład:** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Utrwal konfigurację: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Przykład:** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Zrestartuj sieć za pomocą polecenia: + +```bash +sudo systemctl restart NetworkManager +``` + #### Konfiguracja Windows Na przykład następujące konfiguracje będą korzystać z zakresu adresów IP `192.168.0.0/16` (**maska podsieci**: `255.255.0.0`). diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pt-pt.md b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pt-pt.md index dfba526e825..137f6db9549 100644 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pt-pt.md +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/guide.pt-pt.md @@ -1,13 +1,9 @@ --- title: 'Configurar vários servidores dedicados no vRack' excerpt: 'Aprenda a configurar vários servidores dedicados graças ao vRack' -updated: 2024-10-17 +updated: 2025-03-24 --- -> [!primary] -> Esta tradução foi automaticamente gerada pelo nosso parceiro SYSTRAN. Em certos casos, poderão ocorrer formulações imprecisas, como por exemplo nomes de botões ou detalhes técnicos. Recomendamos que consulte a versão inglesa ou francesa do manual, caso tenha alguma dúvida. Se nos quiser ajudar a melhorar esta tradução, clique em "Contribuir" nesta página. -> - ## Objetivo O vRack (rack virtual) da OVHcloud permite agrupar virtualmente vários servidores (independentemente do seu número e da sua localização física nos nossos datacenters) e ligá-los a um switch virtual dentro da mesma rede privada. Desta forma, os seus servidores podem comunicar de forma privada e segura entre eles, no seio de uma VLAN dedicada. @@ -56,9 +52,9 @@ Por exemplo, os detalhes de configuração abaixo terão o endereço IP `192.168 Pode utilizar qualquer intervalo de IP privados à sua escolha e qualquer endereço nesta praia. > -#### Configurações GNU/Linux +#### Identificação da interface vRack -Os nomes das interfaces de rede dos seus servidores nem sempre são os mesmos. Nos exemplos abaixo, substitua NETWORK_INTERFACE pelo nome de interface adequado. +Os nomes das interfaces de rede dos seus servidores nem sempre são os mesmos. A melhor forma de verificar a interface correta para o vRack é verificar o separador `Interfaces de rede`{.action} do seu servidor na sua [Área de Cliente OVHcloud](/links/manager). Na tabela abaixo, tome nota do endereço MAC, que é também o **nome** da interface **Privada**. @@ -76,24 +72,30 @@ Na linha que começa por ```link ether```, pode verificar que esta interface cor link ether f0:00:00:ef:0e:f0 ``` +#### Configurações GNU/Linux + ##### **Debian 12** Com a ajuda do editor de texto à sua escolha, abra o ficheiro de configuração de rede que se encontra em `/etc/netplan/` para o editar. Aqui, o ficheiro chama-se `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Adicione a configuração IP à configuração existente após a linha `ethernets`: +Adicione as seguintes linhas à configuração existente após a linha `version: 2`. Substitua `NETWORK_INTERFACE` e `IP_ADDRESS/PREFIX` pelos seus próprios valores. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Exemplo:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > É importante respeitar o alinhamento de cada elemento nos ficheiros `yaml`, como representado no exemplo acima. Não utilize a tecla de tabulação para criar o seu espaçamento. Só deve ser utilizada a tecla de espaço. @@ -104,7 +106,7 @@ Registe as suas modificações no ficheiro de configuração e saia do editor. Aplicar a configuração: ```bash -netplan apply +sudo netplan apply ``` Repita este procedimento para os seus outros servidores e atribua a cada um deles um endereço IP não utilizado a partir do seu intervalo privado. A partir daí, os seus servidores poderão comunicar entre si na rede privada. @@ -114,24 +116,28 @@ Repita este procedimento para os seus outros servidores e atribua a cada um dele Num editor de texto, abra o ficheiro de configuração de rede situado em `/etc/network/interfaces.d` para o alterar. Aqui, o ficheiro chama-se `50-cloud-init`. ```bash -editor /etc/network/interfaces.d/50-cloud-init +sudo nano /etc/network/interfaces.d/50-cloud-init ``` -Adicione as seguintes linhas: +Adicione as seguintes linhas à configuração existente, substitua `NETWORK_INTERFACE`, `IP_ADDRESS` e `NETMASK` pelos seus próprios valores: ```console auto NETWORK_INTERFACE -iface NETWORK_INTERFACE -address 192.168.0.1 -netmask 255.255.0.0 +iface NETWORK_INTERFACE inet static + address IP_ADDRESS + netmask NETMASK ``` +**Exemplo:** + +![debian config](images/debian_configuration.png){.thumbnail} + Registe as suas modificações no ficheiro de configuração e saia do editor. Reinicie o serviço de rede para aplicar a configuração: ```bash -systemctl restart networking +sudo systemctl restart networking ``` Repita este procedimento para os seus outros servidores e atribua a cada um deles um endereço IP não utilizado a partir do seu intervalo privado. A partir daí, os seus servidores poderão comunicar entre si na rede privada. @@ -141,19 +147,23 @@ Repita este procedimento para os seus outros servidores e atribua a cada um dele Com a ajuda do editor de texto à sua escolha, abra o ficheiro de configuração de rede que se encontra em `/etc/netplan/` para o editar. Aqui, o ficheiro chama-se `50-cloud-init.yaml`. ```bash -editor /etc/netplan/50-cloud-init.yaml +sudo nano /etc/netplan/50-cloud-init.yaml ``` -Adicione a configuração IP à configuração existente após a linha `ethernets`: +Adicione as seguintes linhas à configuração existente após a linha `version: 2`. Substitua `NETWORK_INTERFACE` e `IP_ADDRESS/PREFIX` pelos seus próprios valores. ```yaml ethernets: NETWORK_INTERFACE: - dhcp4: no + dhcp4: false addresses: - - 192.168.0.1/16 + - IP_ADDRESS/PREFIX ``` +**Exemplo:** + +![netplan config](images/netplan_configuration.png){.thumbnail} + > [!warning] > > É importante respeitar o alinhamento de cada elemento nos ficheiros `yaml`, como representado no exemplo acima. Não utilize a tecla de tabulação para criar o seu espaçamento. Só deve ser utilizada a tecla de espaço. @@ -164,46 +174,145 @@ Registe as suas modificações no ficheiro de configuração e saia do editor. Aplicar a configuração: ```bash -netplan apply +sudo netplan apply ``` Repita este procedimento para os seus outros servidores e atribua a cada um deles um endereço IP não utilizado a partir do seu intervalo privado. A partir daí, os seus servidores poderão comunicar entre si na rede privada. -##### **CentOS** +##### **CentOS, AlmaLinux e RockyLinux** -Com a ajuda do editor de texto à sua escolha, abra o ficheiro `/etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE`. +Depois de identificar a interface de rede privada, utilize um editor de texto para criar o ficheiro de configuração de rede seguinte. Substitua `NETWORK_INTERFACE` pelo seu próprio valor. ```bash -editor /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE +sudo touch /etc/sysconfig/network-scripts/ifcfg-NETWORK_INTERFACE ``` -Adicionar estas linhas: +Adicione estas linhas, substituindo `NETWORK_INTERFACE`, `IP_ADDRESS` e `NETMASK` pelos seus próprios valores: ```console DEVICE=NETWORK_INTERFACE BOOTPROTO=static -IPADDR=192.168.0.1 -NETMASK=255.255.0.0 +IPADDR=IP_ADDRESS +NETMASK=NETMASK ONBOOT=yes TYPE=Ethernet ``` +**Exemplo:** + +![centos config](images/centos_alma_configuration.png){.thumbnail} + Registe as suas modificações no ficheiro de configuração e saia do editor. Reinicie o serviço de rede para aplicar as modificações: ```bash -systemctl restart networking +sudo systemctl restart networking ``` -Em **CentOS 8**, utilize este comando: +Em **CentOS 8, AlmaLinux et RockyLinux**, utilize este comando: ```bash -systemctl restart NetworkManager.service +sudo systemctl restart NetworkManager.service ``` Repita este procedimento para os seus outros servidores e atribua a cada um deles um endereço IP não utilizado a partir do seu intervalo privado. A partir daí, os seus servidores poderão comunicar entre si na rede privada. +##### Fedora + +Depois de identificar o nome da sua interface privada (como explicado [aqui](#vrack-interface)), execute o comando seguinte para verificar se ela está corretamente ligada. No nosso exemplo, a nossa interface é chamada `eno2`: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +lo loopback connected (externally) lo +eno2 ethernet disconnected -- +``` + +Se o `STATE` do `DEVICE` aparecer como `disconnected`, é necessário ligá-lo antes de configurar o IP. + +Ao adicionar uma ligação **ethernet**, é necessário criar um perfil de configuração que atribuiremos a um dispositivo. + +Execute o seguinte comando, substituindo `INTERFACE_NAME` e `CONNECTION_NAME` pelos seus próprios valores. + +No nosso exemplo, nomeámos o nosso perfil de configuração `private-interface`. + +```bash +nmcli connection add type ethernet con-name CONNECTION_NAME ifname INTERFACE_NAME +``` + +**Exemplo:** + +```bash +nmcli connection add type ethernet con-name private-interface ifname eno2 +``` + +- Verifique se a interface está ligada corretamente: + +```bash +$ nmcli device status + +DEVICE TYPE STATE CONNECTION +eno1 ethernet connected cloud-init eno1 +eno2 ethernet connected private-interface +lo loopback connected (externally) lo +``` + +Depois de fazer isto, será criado um novo ficheiro de configuração chamado *xxxxxxxxx.nmconnection* na pasta `/etc/NetworkManager/system-connections`. + + +```bash +[user@server ~]$ cd /etc/NetworkManager/system-connections +[user@server system-connections]$ ls +cloud-init-eno1.nmconnection private-interface.nmconnection +``` + +Pode editar este ficheiro utilizando o gestor `nmcli`, substituindo `IP_ADDRESS`, `PREFIX` e `CONNECTION_NAME` pelos seus próprios valores. + +- Adicione o seu IP: + +```bash +nmcli connection modify CONNECTION_NAME IPv4.address IP_ADDRESS/PREFIX +``` + +**Exemplo:** + +```bash +nmcli connection modify private-interface IPv4.address 192.168.0.1/16 +``` + +- Alterar a configuração de **auto** para **manual*: + +```bash +sudo nmcli connection modify CONNECTION_NAME IPv4.method manual +``` + +**Exemplo:** + +```bash +sudo nmcli connection modify private-interface IPv4.method manual +``` + +- Faça a configuração persistente: + +```bash +sudo nmcli con mod CONNECTION_NAME connection.autoconnect true +``` + +**Exemplo:** + +```bash +sudo nmcli con mod private-interface connection.autoconnect true +``` + +- Reinicie a sua rede com o seguinte comando: + +```bash +sudo systemctl restart NetworkManager +``` + #### Configuração Windows A título de exemplo, as seguintes configurações utilizarão o intervalo de endereços IP de `192.168.0.0/16` (**Máscara de sub-rede**: `255.255.0.0`). diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/centos_alma_configuration.png b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/centos_alma_configuration.png new file mode 100644 index 00000000000..b76cf789804 Binary files /dev/null and b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/centos_alma_configuration.png differ diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/debian_configuration.png b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/debian_configuration.png new file mode 100644 index 00000000000..a0ca00809f6 Binary files /dev/null and b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/debian_configuration.png differ diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/netplan_configuration.png b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/netplan_configuration.png new file mode 100644 index 00000000000..d1db0590fe6 Binary files /dev/null and b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/images/netplan_configuration.png differ diff --git a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/meta.yaml b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/meta.yaml index 964b6a44cf2..c9383360afb 100755 --- a/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/meta.yaml +++ b/pages/bare_metal_cloud/dedicated_servers/vrack_configuring_on_dedicated_server/meta.yaml @@ -1,2 +1,3 @@ id: 4c6dd868-78e8-4de1-a189-2a3ee3950026 -full_slug: dedicated-servers-configuring-vrack \ No newline at end of file +full_slug: dedicated-servers-configuring-vrack +translation_banner: true \ No newline at end of file