Bare Metal Provisioning

1. Configure the shell to access Identity as the administrative user:

   $ source ~/stackrc

   Copy to Clipboard Toggle word wrap

2. Copy the network_data.yaml file:

   (undercloud) [stack@host01 ~]$ cp /usr/share/openstack-tripleo-heat-templates/network_data.yaml .

   Copy to Clipboard Toggle word wrap

3. Edit the new network_data.yaml file and add a new network for IPv4 overcloud provisioning:

   # custom network for overcloud provisioning
   - name: OcProvisioning
   name_lower: oc_provisioning
   vip: true
   vlan: 205
   ip_subnet: '172.23.3.0/24'
   allocation_pools: [{'start': '172.23.3.10', 'end': '172.23.3.200'}]

   Copy to Clipboard Toggle word wrap

4. Update the network_environments.yaml and nic-configs/controller.yaml files to use the new network.

   1. In the network_environments.yaml file, remap Ironic networks:

      ServiceNetMap:
         IronicApiNetwork: oc_provisioning
         IronicNetwork: oc_provisioning

      Copy to Clipboard Toggle word wrap

   2. In the nic-configs/controller.yaml file, add an interface and necessary parameters:

      $network_config:
           - type: vlan
               vlan_id:
                 get_param: OcProvisioningNetworkVlanID
               addresses:
               - ip_netmask:
                   get_param: OcProvisioningIpSubnet

      Copy to Clipboard Toggle word wrap

5. Copy the roles_data.yaml file:

   (undercloud) [stack@host01 ~]$ cp /usr/share/openstack-tripleo-heat-templates/roles_data.yaml .

   Copy to Clipboard Toggle word wrap

6. Edit the new roles_data.yaml and add the new network for the controller:

     networks:
      ...
       OcProvisioning:
         subnet: oc_provisioning_subnet

   Copy to Clipboard Toggle word wrap

7. Include the new network_data.yaml and roles_data.yaml files in the deploy command:

   -n /home/stack/network_data.yaml \
   -r /home/stack/roles_data.yaml \

   Copy to Clipboard Toggle word wrap

Procedure

1. Configure the shell to access Identity as the administrative user:

   $ source ~/stackrc

   Copy to Clipboard Toggle word wrap

2. Copy the network_data.yaml file:

   $ cp /usr/share/openstack-tripleo-heat-templates/network_data.yaml .

   Copy to Clipboard Toggle word wrap

3. Edit the new network_data.yaml file and add a new network for overcloud provisioning:

   # custom network for IPv6 overcloud provisioning
   - name: OcProvisioningIPv6
   vip: true
   name_lower: oc_provisioning_ipv6
   vlan: 10
   ipv6: true
   ipv6_subnet: '$IPV6_SUBNET_ADDRESS/$IPV6_MASK'
   ipv6_allocation_pools: [{'start': '$IPV6_START_ADDRESS', 'end': '$IPV6_END_ADDRESS'}]
   gateway_ipv6: '$IPV6_GW_ADDRESS'

   Copy to Clipboard Toggle word wrap
   • Replace $IPV6_ADDRESS with the IPv6 address of your IPv6 subnet.
   • Replace $IPV6_MASK with the IPv6 network mask for your IPv6 subnet.
   • Replace $IPV6_START_ADDRESS and $IPV6_END_ADDRESS with the IPv6 range that you want to use for address allocation.
   • Replace $IPV6_GW_ADDRESS with the IPv6 address of your gateway.

4. Create a new file network-environment.yaml and define IPv6 settings for the provisioning network:

   $ touch /home/stack/network-environment.yaml`

   Copy to Clipboard Toggle word wrap

   1. Remap the ironic networks to use the new IPv6 provisioning network:

      ServiceNetMap:
         IronicApiNetwork: oc_provisioning_ipv6
         IronicNetwork: oc_provisioning_ipv6

      Copy to Clipboard Toggle word wrap

   2. Set the IronicIpVersion parameter to 6:

      parameter_defaults:
        IronicIpVersion: 6

      Copy to Clipboard Toggle word wrap

   3. Set the RabbitIPv6, MysqlIPv6, and RedisIPv6 parameters to True:

      parameter_defaults:
        RabbitIPv6: True
        MysqlIPv6: True
        RedisIPv6: True

      Copy to Clipboard Toggle word wrap

   4. Set the ControlPlaneSubnetCidr parameter to the subnet IPv6 mask length for the provisioning network:

      parameter_defaults:
        ControlPlaneSubetCidr: '64'

      Copy to Clipboard Toggle word wrap

   5. Set the ControlPlaneDefaultRoute parameter to the IPv6 address of the gateway router for the provisioning network:

      parameter_defaults:
        ControlPlaneDefaultRoute: <ipv6-address>

      Copy to Clipboard Toggle word wrap

5. Add an interface and necessary parameters to the nic-configs/controller.yaml file:

   $network_config:
        - type: vlan
            vlan_id:
              get_param: OcProvisioningIPv6NetworkVlanID
            addresses:
            - ip_netmask:
                get_param: OcProvisioningIPv6IpSubnet

   Copy to Clipboard Toggle word wrap

6. Copy the roles_data.yaml file:

   (undercloud) [stack@host01 ~]$ cp /usr/share/openstack-tripleo-heat-templates/roles_data.yaml .

   Copy to Clipboard Toggle word wrap

7. Edit the new roles_data.yaml and add the new network for the controller:

     networks:
      ...
       - OcProvisioningIPv6

   Copy to Clipboard Toggle word wrap

1. Configure the shell to access Identity as the administrative user:

   $ source ~/overcloudrc

   Copy to Clipboard Toggle word wrap

2. Create the flat network over which to provision bare metal instances:

   $ openstack network create \
     --provider-network-type flat \
     --provider-physical-network baremetal \
     --share NETWORK_NAME

   Copy to Clipboard Toggle word wrap

   Replace NETWORK_NAME with a name for this network. The name of the physical network over which the virtual network is implemented (in this case baremetal) was set earlier in the ~/templates/network-environment.yaml file, with the parameter NeutronBridgeMappings.

3. Create the subnet on the flat network:

   $ openstack subnet create \
     --network NETWORK_NAME \
     --subnet-range NETWORK_CIDR \
     --ip-version 4 \
     --gateway GATEWAY_IP \
     --allocation-pool start=START_IP,end=END_IP \
     --dhcp SUBNET_NAME

   Copy to Clipboard Toggle word wrap

   Replace the following values:

   • Replace SUBNET_NAME with a name for the subnet.
   • Replace NETWORK_NAME with the name of the provisioning network that you created in the previous step.
   • Replace NETWORK_CIDR with the Classless Inter-Domain Routing (CIDR) representation of the block of IP addresses that the subnet represents. The block of IP addresses specified by the range starting with START_IP and ending with END_IP must fall within the block of IP addresses specified by NETWORK_CIDR.
   • Replace GATEWAY_IP with the IP address or host name of the router interface that acts as the gateway for the new subnet. This address must be within the block of IP addresses specified by NETWORK_CIDR, but outside of the block of IP addresses specified by the range starting with START_IP and ending with END_IP.
   • Replace START_IP with the IP address that denotes the start of the range of IP addresses within the new subnet from which floating IP addresses will be allocated.
   • Replace END_IP with the IP address that denotes the end of the range of IP addresses within the new subnet from which floating IP addresses will be allocated.

4. Create a router for the network and subnet to ensure that the OpenStack Networking Service serves metadata requests:

   $ openstack router create ROUTER_NAME

   Copy to Clipboard Toggle word wrap

   Replace ROUTER_NAME with a name for the router.

5. Attach the subnet to the new router:

   $ openstack router add subnet ROUTER_NAME BAREMETAL_SUBNET

   Copy to Clipboard Toggle word wrap

   Replace ROUTER_NAME with the name of your router and BAREMETAL_SUBNET with the ID or name of the subnet that you created previously. This allows the metadata requests from cloud-init to be served and the node configured.

1. Create a vlan network with a VlanID that matches the OcProvisioning network that you create during deployment. Name the new network provisioning to match the default name of the cleaning network.

   (overcloud) [stack@host01 ~]$ openstack network create \
     --share \
     --provider-network-type vlan \
     --provider-physical-network datacentre \
     --provider-segment 205 provisioning

   Copy to Clipboard Toggle word wrap

   If the name of the overcloud network is not provisioning, log in to the controller and run the following commands to rename and restart the network:

   heat-admin@overcloud-controller-0 ~]$ sudo vi /var/lib/config-data/puppet-generated/ironic/etc/ironic/ironic.conf

   Copy to Clipboard Toggle word wrap

   heat-admin@overcloud-controller-0 ~]$ sudo podman restart ironic_conductor

   Copy to Clipboard Toggle word wrap

1. Download the Red Hat Enterprise Linux KVM guest image from the Customer Portal (requires login).

2. Define DIB_LOCAL_IMAGE as the downloaded image:

   $ export DIB_LOCAL_IMAGE=rhel-8.0-x86_64-kvm.qcow2

   Copy to Clipboard Toggle word wrap

3. Set your registration information. If you use Red Hat Customer Portal, you must configure the following information:

   $ export REG_USER='USER_NAME'
   $ export REG_PASSWORD='PASSWORD'
   $ export REG_AUTO_ATTACH=true
   $ export REG_METHOD=portal
   $ export https_proxy='IP_address:port' (if applicable)
   $ export http_proxy='IP_address:port' (if applicable)

   Copy to Clipboard Toggle word wrap

   If you use Red Hat Satellite, you must configure the following information:

   $ export REG_USER='USER_NAME'
   $ export REG_PASSWORD='PASSWORD'
   $ export REG_SAT_URL='<SATELLITE URL>'
   $ export REG_ORG='<SATELLITE ORG>'
   $ export REG_ENV='<SATELLITE ENV>'
   $ export REG_METHOD=<METHOD>

   Copy to Clipboard Toggle word wrap

   If you have any offline repositories, you can define DIB_YUM_REPO_CONF as local repository configuration:

   $ export DIB_YUM_REPO_CONF=<path-to-local-repository-config-file>

   Copy to Clipboard Toggle word wrap

4. Create the user images using the diskimage-builder tool:

   $ disk-image-create rhel8 baremetal -o rhel-image

   Copy to Clipboard Toggle word wrap

   This command extracts the kernel as rhel-image.vmlinuz and initial ramdisk as rhel-image.initrd.

5. Upload the images to the Image service:

   $ KERNEL_ID=$(openstack image create \
     --file rhel-image.vmlinuz --public \
     --container-format aki --disk-format aki \
     -f value -c id rhel-image.vmlinuz)
   $ RAMDISK_ID=$(openstack image create \
     --file rhel-image.initrd --public \
     --container-format ari --disk-format ari \
     -f value -c id rhel-image.initrd)
   $ openstack image create \
     --file rhel-image.qcow2   --public \
     --container-format bare \
     --disk-format qcow2 \
     --property kernel_id=$KERNEL_ID \
     --property ramdisk_id=$RAMDISK_ID \
     rhel-image

   Copy to Clipboard Toggle word wrap

1. The Nova scheduler receives a boot instance request from the Nova API.
2. The Nova scheduler identifies the relevant hypervisor and identifies the target physical node.
3. The Nova compute manager claims the resources of the selected hypervisor.
4. The Nova compute manager creates unbound tenant virtual interfaces (VIFs) in the Networking service according to the network interfaces that the nova boot request specifies.

5. Nova compute invokes driver.spawn from the Nova compute virt layer to create a spawn task that contains all of the necessary information. During the spawn process, the virt driver completes the following steps.

   1. Updates the target ironic node with information about the deploy image, instance UUID, requested capabilities, and flavor propertires.
   2. Calls the ironic API to validate the power and deploy interfaces of the target node.
   3. Attaches the VIFs to the node. Each neutron port can be attached to any ironic port or group. Port groups have higher priority than ports.
   4. Generates config drive.
6. The Nova ironic virt driver issues a deploy request with the Ironic API to the Ironic conductor that services the bare metal node.
7. Virtual interfaces are plugged in and the Neutron API updates DHCP to configure PXE/TFTP options.
8. The ironic node boot interface prepares (i)PXE configuration and caches the deploy kernel and ramdisk.
9. The ironic node management interface issues commands to enable network boot of the node.
10. The ironic node deploy interface caches the instance image, kernel, and ramdisk, if necessary.
11. The ironic node power interface instructs the node to power on.
12. The node boots the deploy ramdisk.
13. With iSCSI deployment, the conductor copies the image over iSCSI to the physical node. With direct deployment, the deploy ramdisk downloads the image from a temporary URL. This URL must be a Swift API compatible object store or a HTTP URL.
14. The node boot interface switches PXE configuration to refer to instance images and instructs the ramdisk agent to soft power off the node. If the soft power off fails, the bare metal node is powered off with IPMI/BMC.
15. The deploy interface instructs the network interface to remove any provisioning ports, binds the tenant ports to the node, and powers the node on.

1. Create or modify a custom environment file /home/stack/templates/direct_deploy.yaml and specify the IronicEnabledDeployInterfaces and the IronicDefaultDeployInterface parameters.

   parameter_defaults:
     IronicEnabledDeployInterfaces: direct
     IronicDefaultDeployInterface: direct

   Copy to Clipboard Toggle word wrap

   If you register your nodes with iscsi, retain the iscsi value in the IronicEnabledDeployInterfaces parameter:

   parameter_defaults:
     IronicEnabledDeployInterfaces: direct,iscsi
     IronicDefaultDeployInterface: direct

   Copy to Clipboard Toggle word wrap

2. By default, the Bare Metal Service (ironic) agent on each node obtains the image stored in the Object Storage Service (swift) through a HTTP link. Alternatively, Ironic can stream this image directly to the node through the ironic-conductor HTTP server. To change the service providing the image, set the IronicImageDownloadSource to http in the /home/stack/templates/direct_deploy.yaml file:

   parameter_defaults:
     IronicEnabledDeployInterfaces: direct
     IronicDefaultDeployInterface: direct
     IronicImageDownloadSource: http

   Copy to Clipboard Toggle word wrap

3. Include the custom environment with your overcloud deployment:

   $ openstack overcloud deploy \
     --templates \
     ...
     -e /usr/share/openstack-tripleo-heat-templates/environments/services/ironic.yaml \
     -e /home/stack/templates/direct_deploy.yaml \
     ...

   Copy to Clipboard Toggle word wrap

   Wait until deployment completes.

1. Create a file overcloud-nodes.yaml, including the node details. You can enroll multiple nodes with one file.

   nodes:
       - name: node0
         driver: ipmi
         driver_info:
           ipmi_address: <IPMI_IP>
           ipmi_username: <USER>
           ipmi_password: <PASSWORD>
         properties:
           cpus: <CPU_COUNT>
           cpu_arch: <CPU_ARCHITECTURE>
           memory_mb: <MEMORY>
           local_gb: <ROOT_DISK>
           root_device:
               serial: <SERIAL>
         ports:
           - address: <PXE_NIC_MAC>

   Copy to Clipboard Toggle word wrap

   Replace the following values:

   • <IPMI_IP> with the address of the Bare Metal controller.
   • <USER> with your username.
   • <PASSWORD> with your password.
   • <CPU_COUNT> with the number of CPUs.
   • <CPU_ARCHITECTURE> with the type of architecture of the CPUs.
   • <MEMORY> with the amount of memory in MiB.
   • <ROOT_DISK> with the size of the root disk in GiB.

   • <MAC_ADDRESS> with the MAC address of the NIC used to PXE boot.

     You must include root_device only if the machine has multiple disks. Replace <SERIAL> with the serial number of the disk that you want to use for deployment.

2. Configure the shell to use Identity as the administrative user:

   $ source ~/overcloudrc

   Copy to Clipboard Toggle word wrap

3. Import the inventory file into ironic:

   $ openstack baremetal create overcloud-nodes.yaml

   Copy to Clipboard Toggle word wrap
4. The nodes are now in the enroll state.

5. Specify the deploy kernel and deploy ramdisk on each node:

   $ openstack baremetal node set NODE_UUID \
     --driver-info deploy_kernel=KERNEL_UUID \
     --driver-info deploy_ramdisk=INITRAMFS_UUID

   Copy to Clipboard Toggle word wrap

   Replace the following values:

   • Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name.

   • Replace KERNEL_UUID with the unique identifier for the kernel deploy image that was uploaded to the Image service. Find this value with the following command:

     $ openstack image show bm-deploy-kernel -f value -c id

     Copy to Clipboard Toggle word wrap

   • Replace INITRAMFS_UUID with the unique identifier for the ramdisk image that was uploaded to the Image service. Find this value with the following command:

     $ openstack image show bm-deploy-ramdisk -f value -c id

     Copy to Clipboard Toggle word wrap

6. Set the node’s provisioning state to available:

   $ openstack baremetal node manage _NODE_UUID_
   $ openstack baremetal node provide _NODE_UUID_

   Copy to Clipboard Toggle word wrap

   The bare metal service cleans the node if you enabled node cleaning,

7. Check that the nodes were successfully enrolled:

   $ openstack baremetal node list

   Copy to Clipboard Toggle word wrap

   There may be a delay between enrolling a node and its state being shown.

1. Configure the shell to use Identity as the administrative user:

   $ source ~/overcloudrc

   Copy to Clipboard Toggle word wrap

2. Add a new node:

   $ openstack baremetal node create --driver ipmi --name NAME

   Copy to Clipboard Toggle word wrap

   To create a node, you must specify the driver name. This example uses ipmi. To use a different driver, you must enable the driver by setting the IronicEnabledHardwareTypes parameter. For more information on supported drivers, see Appendix A, Bare Metal Drivers.

   Important

   Note the unique identifier for the node.

3. Update the node driver information to allow the Bare Metal service to manage the node:

   $ openstack baremetal node set NODE_UUID \
     --driver_info PROPERTY=VALUE \
     --driver_info PROPERTY=VALUE

   Copy to Clipboard Toggle word wrap

   Replace the following values:

   • Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name.
   • Replace PROPERTY with a required property returned by the ironic driver-properties command.
   • Replace VALUE with a valid value for that property.

4. Specify the deploy kernel and deploy ramdisk for the node driver:

   $ openstack baremetal node set NODE_UUID \
     --driver-info deploy_kernel=KERNEL_UUID \
     --driver-info deploy_ramdisk=INITRAMFS_UUID

   Copy to Clipboard Toggle word wrap

   Replace the following values:

   • Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name.
   • Replace KERNEL_UUID with the unique identifier for the .kernel image that was uploaded to the Image service.
   • Replace INITRAMFS_UUID with the unique identifier for the .initramfs image that was uploaded to the Image service.

5. Update the node’s properties to match the hardware specifications on the node:

   $ openstack baremetal node set NODE_UUID \
     --property cpus=CPU \
     --property memory_mb=RAM_MB \
     --property local_gb=DISK_GB \
     --property cpu_arch=ARCH

   Copy to Clipboard Toggle word wrap

   Replace the following values:

   • Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name.
   • Replace CPU with the number of CPUs.
   • Replace RAM_MB with the RAM (in MB).
   • Replace DISK_GB with the disk size (in GB).
   • Replace ARCH with the architecture type.

6. OPTIONAL: Configure the node to reboot after initial deployment from a local boot loader installed on the node’s disk, instead of using PXE from ironic-conductor. You must also set the local boot capability on the flavor used to provision the node. To enable local boot, the image used to deploy the node must contain grub2. Configure local boot:

   $ openstack baremetal node set NODE_UUID \
     --property capabilities="boot_option:local"

   Copy to Clipboard Toggle word wrap

   Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name.

7. Inform the Bare Metal service of the node’s network card by creating a port with the MAC address of the NIC on the provisioning network:

   $ openstack baremetal port create --node NODE_UUID MAC_ADDRESS

   Copy to Clipboard Toggle word wrap

   Replace NODE_UUID with the unique identifier for the node. Replace MAC_ADDRESS with the MAC address of the NIC used to PXE boot.

8. If you have multiple disks, set the root device hints. This informs the deploy ramdisk which disk it should use for deployment.

   $ openstack baremetal node set NODE_UUID \
     --property root_device={"PROPERTY": "VALUE"}

   Copy to Clipboard Toggle word wrap

   Replace with the following values:

   • Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name.

   • Replace PROPERTY and VALUE with details about the disk that you want to use for deployment, for example root_device='{"size": 128}'

     The following properties are supported:

     • model (String): Device identifier.
     • vendor (String): Device vendor.
     • serial (String): Disk serial number.
     • hctl (String): Host:Channel:Target:Lun for SCSI.
     • size (Integer): Size of the device in GB.
     • wwn (String): Unique storage identifier.
     • wwn_with_extension (String): Unique storage identifier with the vendor extension appended.
     • wwn_vendor_extension (String): Unique vendor storage identifier.
     • rotational (Boolean): True for a rotational device (HDD), otherwise false (SSD).

     • name (String): The name of the device, for example: /dev/sdb1 Use this property only for devices with persistent names.

       Note

       If you specify more than one property, the device must match all of those properties.

9. Validate the configuration of the node:

   $ openstack baremetal node validate NODE_UUID
   +------------+--------+---------------------------------------------+
   | Interface  | Result | Reason                                      |
   +------------+--------+---------------------------------------------+
   | boot       | False  | Cannot validate image information for node  |
   |            |        | a02178db-1550-4244-a2b7-d7035c743a9b        |
   |            |        | because one or more parameters are missing  |
   |            |        | from its instance_info. Missing are:        |
   |            |        | ['ramdisk', 'kernel', 'image_source']       |
   | console    | None   | not supported                               |
   | deploy     | False  | Cannot validate image information for node  |
   |            |        | a02178db-1550-4244-a2b7-d7035c743a9b        |
   |            |        | because one or more parameters are missing  |
   |            |        | from its instance_info. Missing are:        |
   |            |        | ['ramdisk', 'kernel', 'image_source']       |
   | inspect    | None   | not supported                               |
   | management | True   |                                             |
   | network    | True   |                                             |
   | power      | True   |                                             |
   | raid       | True   |                                             |
   | storage    | True   |                                             |
   +------------+--------+---------------------------------------------+

   Copy to Clipboard Toggle word wrap

   Replace NODE_UUID with the unique identifier for the node. Alternatively, use the node’s logical name. The output of the openstack baremetal node validate command should report either True or None for each interface. Interfaces marked None are those that you have not configured, or those that are not supported for your driver.

   Note

   Interfaces may fail validation due to missing 'ramdisk', 'kernel', and 'image_source' parameters. This result is fine, because the Compute service populates those missing parameters at the beginning of the deployment process.

Procedure

1. Set the Bare Metal service (ironic) boot interface to redfish-virtual-media:

   $ openstack baremetal node set --boot-interface redfish-virtual-media $NODE_NAME

   Copy to Clipboard Toggle word wrap

   Replace $NODE_NAME with the name of the node.

2. For UEFI nodes, set the boot mode to uefi:

   $ openstack baremetal node set --property capabilities="boot_mode:uefi" $NODE_NAME

   Copy to Clipboard Toggle word wrap

   Replace $NODE_NAME with the name of the node.

   Note

   For BIOS nodes, do not complete this step.

3. For UEFI nodes, define the EFI System Partition (ESP) image:

   $ openstack baremetal node set --driver-info bootloader=$ESP $NODE_NAME

   Copy to Clipboard Toggle word wrap

   Replace $ESP with the glance image UUID or URL for the ESP image, and replace $NODE_NAME with the name of the node.

   Note

   For BIOS nodes, do not complete this step.

4. Create a port on the bare metal node and associate the port with the MAC address of the NIC on the bare metal node:

   $ openstack baremetal port create --pxe-enabled True --node $UUID $MAC_ADDRESS

   Copy to Clipboard Toggle word wrap

   Replace $UUID with the UUID of the bare metal node, and replace $MAC_ADDRESS with the MAC address of the NIC on the bare metal node.

5. Create the new bare metal server:

   $ openstack server create \
       --flavor baremetal \
       --image $IMAGE \
       --network $NETWORK \
       test_instance

   Copy to Clipboard Toggle word wrap

   Replace $IMAGE and $NETWORK with the names of the image and network that you want to use.

1. Create a port group by specifying the node to which it belongs, its name, address, mode, properties and whether it supports fallback to standalone ports.

   # openstack baremetal port group create --node NODE_UUID --name NAME --address MAC_ADDRESS --mode MODE  --property miimon=100 --property xmit_hash_policy="layer2+3" --support-standalone-ports

   Copy to Clipboard Toggle word wrap

   You can also update a port group using the openstack baremetal port group set command.

   If you do not specify an address, the deployed instance port group address is the same as the OpenStack Networking port. The port group will not be configured if the neutron port is not attached.

   During interface attachment, port groups have a higher priority than the ports, so they are used first. Currently, it is not possible to specify whether a port group or a port is desired in an interface attachment request. Port groups that do not have any ports will be ignored.

   Note

   Port groups must be configured manually in standalone mode either in the image or by generating the configdrive and adding it to the node’s instance_info. Ensure that you have cloud-init version 0.7.7 or later for the port group configuration to work.

2. Associate a port with a port group:

   • During port creation:

     # openstack baremetal port create --node NODE_UUID --address MAC_ADDRESS --port-group test

     Copy to Clipboard Toggle word wrap

   • During port update:

     # openstack baremetal port set PORT_UUID --port-group PORT_GROUP_UUID

     Copy to Clipboard Toggle word wrap

3. Boot an instance by providing an image that has cloud-init or supports bonding.

   To check if the port group has been configured properly, run the following command:

   # cat /proc/net/bonding/bondX

   Copy to Clipboard Toggle word wrap

   Here, X is a number autogenerated by cloud-init for each configured port group, starting with a 0 and incremented by one for each configured port group.

Procedure

1. Create the provisioning network and subnet. This depends on the type of provisioning network you are using. See Chapter 4, Configuring for the Bare Metal Service After Deployment for information on configuring the provisioning network.

2. Create a tenant network and subnet:

   $ openstack network create --provider-network-type vlan --provider-physical-network baremetal tenant-net
   $ openstack subnet create --network tenant-net --subnet-range 192.168.3.0/24 --allocation-pool start=192.168.3.10,end=192.168.3.20 tenant-subnet

   Copy to Clipboard Toggle word wrap

   Ensure that you set the --provider-network-type option to vlan to ensure networking-ansible functionality.

Procedure

1. Create the provisioning network and subnet. This depends on the type of provisioning network you are using. See Chapter 4, Configuring for the Bare Metal Service After Deployment for information on configuring the provisioning network.

2. Create a primary tenant VLAN network, a secondary tenant network, and subnets for each network that use the physical network that the guest is attached to:

   $ openstack network create --provider-network-type vlan --provider-physical-network baremetal primary-tenant-net
   $ openstack network create --provider-network-type vlan --provider-physical-network baremetal secondary-tenant-net
   $ openstack subnet create --network primary-tenant-net --subnet-range 192.168.3.0/24 --allocation-pool start=192.168.3.10,end=192.168.3.20 primary-tenant-subnet
   $ openstack subnet create --network secondary-tenant-net --subnet-range 192.168.7.0/24 --allocation-pool start=192.168.7.10,end=192.168.7.20 secondary-tenant-subnet

   Copy to Clipboard Toggle word wrap

   Ensure that you set the --provider-network-type option to vlan to ensure networking-ansible functionality.

Procedure

1. Create a port and a trunk, assigning the port to the trunk as the parent port:

   $ port create --network primary-tenant-net primary-port
   $ network trunk create --parent-port primary-port my-trunk

   Copy to Clipboard Toggle word wrap

2. Create a port for the secondary network and add the new port as a subport to the trunk:

   $ port create --network secondary-tenant-net secondary-port
   $ network trunk set --subport port=secondary-port,segmentation-type=vlan,segmentation-id=1234 my-trunk

   Copy to Clipboard Toggle word wrap