15.5. Deploying a multi-cell overcloud

To configure your RHOSP deployment to handle multiple cells, you must complete the following stages:

  1. Extract parameter information from the default first cell in the basic overcloud. This cell becomes the global Controller after you redeploy the overcloud.
  2. Configure a custom role and flavor for each cell.
  3. Create environment files to configure cell-specific parameters.
  4. Deploy the overcloud with the new cell stack.
注記
  • This process adds one cell to the overcloud. Repeat these steps for each additional cell you want to deploy in the overcloud.
  • In this procedure, the name of the new cell is cell1. Replace the name in all commands with the actual cell name.

Prerequisites

  • You have deployed a basic overcloud with the required number of Controller and Compute nodes.

Procedure: Extract parameter information from the overcloud

  1. Create a new directory for the new cell, and export the directory to the DIR environment variable. The example used throughout this procedure is cell1:

    $ source ~/stackrc
    (undercloud)$ mkdir cell1
    (undercloud)$ export DIR=cell1
  2. Export the default cell configuration and password information from the overcloud to a new environment file for the cell:

    (undercloud)$ openstack overcloud cell export \
     --output-file cell1/cell1-ctrl-input.yaml cell1
    注記

    If the environment file already exists, enter the command with the --force-overwrite or -f option.

    This command exports the EndpointMap, HostsEntry, AllNodesConfig, GlobalConfig parameters, and the password information, to the new environment file for the cell, cell1/cell1-ctrl-input.yaml.

Procedure: Configure a custom role for a cell

  1. Generate a new roles data file named cell_roles_data.yaml that includes the Compute and CellController roles:

    (undercloud)$ openstack overcloud roles generate \
      --roles-path /usr/share/openstack-tripleo-heat-templates/roles \
      -o $DIR/cell_roles_data.yaml Compute CellController
  2. Optional: To divide your network between the global Controller and the cells, configure network access in the roles file that you created using segmented network role parameters:

    name: Compute
     description: |
       Basic Compute Node role
     CountDefault: 1
     # Create external Neutron bridge (unset if using ML2/OVS without DVR)
     tags:
       - external_bridge
     networks:
       InternalApi:
         subnet: internal_api_cell1
       Tenant:
         subnet: tenant_subnet
       Storage:
         subnet: storage_cell1
    ...
    - name: CellController
       description: |
         CellController role for the nova cell_v2 controller services
       CountDefault: 1
       tags:
         - primary
         - controller
       networks:
         External:
           subnet: external_cell1
         InternalApi:
           subnet: internal_api_cell1
         Storage:
           subnet: storage_cell1
         StorageMgmt:
           subnet: storage_mgmt_cell1
         Tenant:
           subnet: tenant_subnet

Procedure: Configure the cell flavor and tag nodes to a cell

  1. Create the cellcontroller flavor to use to tag nodes that you want to allocate to the cell. For example:

    (undercloud)$ openstack flavor create --id auto --ram 4096 \
      --disk 40 --vcpus 1 cellcontroller
    (undercloud)$ openstack flavor set --property "cpu_arch"="x86_64" \
     --property "capabilities:boot_option"="local" \
     --property "capabilities:profile"="cellcontroller" \
     --property "resources:CUSTOM_BAREMETAL=1" \
     --property "resources:DISK_GB=0" \
     --property "resources:MEMORY_MB=0" \
     --property "resources:VCPU=0" \
     cellcontroller
  2. Tag each node that you want to assign to the cell with the cellcontroller profile.

    (undercloud)$ openstack baremetal node set --property \
     capabilities='profile:cellcontroller,boot_option:local' <node_uuid>

    Replace <node_uuid> with the ID of the Compute node that you want to assign to the cell.

Procedure: Create environment files with cell parameters

  1. Create a new environment file in the cell directory cell for cell-specific parameters, for example, /cell1/cell1.yaml.
  2. Add the following parameters, updating the parameter values for your deployment:

    resource_registry:
      # since the same networks are used in this example, the
      # creation of the different networks is omitted
      OS::TripleO::Network::External: OS::Heat::None
      OS::TripleO::Network::InternalApi: OS::Heat::None
      OS::TripleO::Network::Storage: OS::Heat::None
      OS::TripleO::Network::StorageMgmt: OS::Heat::None
      OS::TripleO::Network::Tenant: OS::Heat::None
      OS::TripleO::Network::Management: OS::Heat::None
      OS::TripleO::Network::Ports::OVNDBsVipPort: /usr/share/openstack-tripleo-heat-templates/network/ports/noop.yaml
      OS::TripleO::Network::Ports::RedisVipPort: /usr/share/openstack-tripleo-heat-templates/network/ports/noop.yaml
    
    parameter_defaults:
      # CELL Parameter to reflect that this is an additional CELL
      NovaAdditionalCell: True
    
      # mapping of the CellController flavor to the CellController role
      CellControllerFlavor: cellcontroller
    
      # The DNS names for the VIPs for the cell
      CloudName: cell1.ooo.test
      CloudNameInternal: cell1.internalapi.ooo.test
      CloudNameStorage: cell1.storage.ooo.test
      CloudNameStorageManagement: cell1.storagemgmt.ooo.test
      CloudNameCtlplane: cell1.ctlplane.ooo.test
    
      # Flavors used for the cell controller and computes
      OvercloudCellControllerFlavor: cellcontroller
      OvercloudComputeFlavor: compute
    
      # Number of controllers/computes in the cell
      CellControllerCount: 1
      ComputeCount: 1
    
      # Compute node name (must be unique across all cells)
      ComputeHostnameFormat: 'cell1-compute-%index%'
    
      # default gateway
      ControlPlaneStaticRoutes:
        - ip_netmask: 0.0.0.0/0
          next_hop: 192.168.24.1
          default: true
      DnsServers:
        - x.x.x.x
  3. Optional: To allocate a network resource to the cell and register cells to the network, add the following parameter to your environment file:

    resource_registry:
      OS::TripleO::CellController::Net::SoftwareConfig: single-nic-vlans/controller.yaml
      OS::TripleO::Compute::Net::SoftwareConfig: single-nic-vlans/compute.yaml
  4. Optional: If you divide your network between the global Controller and the cells and want to run the Compute metadata API in each cell instead of in the global Controller, add the following parameter:

    parameter_defaults:
      NovaLocalMetadataPerCell: True
    注記
    • The parameters in this file restrict the overcloud to use a single network for all cells.
    • The Compute host names must be unique across all cells.
  5. Make a copy of the network_data.yaml file and rename the copy to include the cell name, for example:

    (undercloud)$ cp /usr/share/openstack-tripleo-heat-templates/network_data.yaml cell1/network_data-ctrl.yaml
  6. Retrieve the UUIDs of the network components that you want to reuse for the cells:

    (undercloud)$ openstack network show <network>
    (undercloud)$ openstack subnet show <subnet>
    (undercloud)$ openstack network segment show <network_segment>
    (undercloud)$ openstack port show <port>
    • Replace <network> with the name of the network whose UUID you want to retrieve.
    • Replace <subnet> with the name of the subnet whose UUID you want to retrieve.
    • Replace <network_segment> with the name of the segment whose UUID you want to retrieve.
    • Replace <port> with the name of the port whose UUID you want to retrieve.
  7. To reuse the network components for the cells, add the following configuration to your new cell network_data.yaml file:

    external_resource_network_id: <network_uuid>
    external_resource_subnet_id: <subnet_uuid>
    external_resource_segment_id: <segment_uuid>
    external_resource_vip_id: <port_uuid>
    • Replace <network_uuid> with the UUID of the network you retrieved in the previous step.
    • Replace <subnet_uuid> with the UUID of the subnet you retrieved in the previous step.
    • Replace <segment_uuid> with the UUID of the segment you retrieved in the previous step.
    • Replace <port_uuid> with the UUID of the port you retrieved in the previous step.
  8. Optional: To configure segmented networks for the global Controller cell and the Compute cells, create an environment file and add the routing information and virtual IP address (VIP) information for the cell. For example, you can add the following configuration for cell1 to the file cell1_routes.yaml:

    parameter_defaults:
      InternalApiInterfaceRoutes:
        - destination: 172.17.2.0/24
          nexthop: 172.16.2.254
      StorageInterfaceRoutes:
        - destination: 172.17.1.0/24
          nexthop: 172.16.1.254
      StorageMgmtInterfaceRoutes:
        - destination: 172.17.3.0/24
          nexthop: 172.16.3.254
    
    parameter_defaults:
      VipSubnetMap:
        InternalApi: internal_api_cell1
        Storage: storage_cell1
        StorageMgmt: storage_mgmt_cell1
        External: external_cell1
  9. Add the environment files to the stack with your other environment files and deploy the overcloud, for example:

    (undercloud)$ openstack overcloud deploy --templates \
     --stack cell1 \
     -e [your environment files] \
     -r $HOME/$DIR/cell_roles_data.yaml \
     -e $HOME/$DIR/cell1_routes.yaml \
     -e $HOME/$DIR/network_data-ctrl.yaml \
     -e $HOME/$DIR/cell1-ctrl-input.yaml \
     -e $HOME/$DIR/cell1.yaml
    注記

    If you deploy Compute cells in Edge sites, enter the overcloud deploy command in each site with the environment files and configuration for each Compute cell in that site.

(Optional) Configure networking for Edge sites

To distribute Compute nodes across Edge sites, create one environment file for the main Controller cell and separate environment files for each Compute cell in that Edge site.

  • In the primary environment file, set the ComputeCount parameter to 0 in the Controller cell. This cell is separate from the Edge site Compute cells, which will contain the actual Compute nodes.
  • In the Compute cell environment files, add the following parameter to disable external VIP ports:

    resource_registry:
      # Since the compute stack deploys only compute nodes ExternalVIPPorts are not required.
      OS::TripleO::Network::Ports::ExternalVipPort: /usr/share/openstack-tripleo-heat-templates/network/ports/noop.yaml