OpenStack实战指南
上QQ阅读APP看书，第一时间看更新
上一章目录下一章

第2章
OpenStack的安装

2.1 在Ubuntu上使用二进制包安装

笔者写本书的时候，OpenStack已经发展到Havana版本，几大主流的Linux发行版本都会将OpenStack的源代码做成各自平台的二进制安装包，以供用户使用。随着OpenStack使用的人越来越多，发行版本对Linux的支持力度也越来越大，就目前来看，Ubuntu（Debian）、RedHat、OpenSUSE都有相应的包和开发定制的安装程序。当然，各个Linux平台上的包制作发布的时间各有快慢，同时支持的版本更新也有快有慢。Ubuntu是更新最快的发行版本之一。RedHat也越来越重视OpenStack，更新包的速度也比以前快很多。这里先以Ubuntu作为底层的操作系统，因为Ubuntu从OpenStack的Cactus版本开始就将其作为自身一个云计算的软件，同时，社区对OpenStack的支持很好，网络上很多文档都是以Ubuntu为操作系统进行部署安装的，并且OpenStack的开发人员是在Ubuntu上进行OpenStack的开发的，就目前情况来看，其支持度最好。

本节将会介绍如何在Ubuntu 12.04 LTS上安装Keystone、Glance、Nova、Neutron、Cinder和Horizon这几个组件，其中使用4台服务器，分别作为controller、network、compute、volume节点。这4个节点的名字只是按照它们需要完成的任务来命名的，并不是说它们有特定的名字。

2.1.1 控制节点的安装

在controller节点上计划部署如下组件：

· RabbitMQ

· MySQL

· Keystone

· Glance

· Neutron

· Nova中除去nova-compute的其他组件

· Cinder中除去cinder-volume的其他组件

· Horizon

下面详细介绍一下各个组件。

RabbitMQ：在OpenStack中，各个服务之间是通过消息来交互的。因为OpenStack使用AMQP（高级消息队列协议）作为其消息传递的技术，所以RabbitMQ、Qpid、ZeroMQ等支持AMQP的软件都是被OpenStack所支持的。这里会使用RabbitMQ，因为它是第一个被OpenStack使用的消息传递的软件。OpenStack通过AMQP实现RPC的服务，来保证不同组件之间的通信，RabbitMQ是controller中一个非常关键的服务。RabbitMQ结构图如图2-1所示。

图2-1 RabbitMQ交互图

MySQL：OpenStack所使用的数据库。包括Nova、Glance、Cinder等在内的组件都会建立自己的数据库，保存一些必要的数据。

Keystone：OpenStack的用户认证组件。它的功能主要是建立管理项目的用户和各种服务端口，以及进行用户的身份认证。要使用OpenStack的任意API，第一步就必须通过Keystone的验证。

Glance：用来存放管理虚拟机镜像和快照的服务，这也是一个最小架构中必须有的服务。

Neutron：用来提供虚拟机网络通信的组件。

Nova（除去nova-compute的其他组件）：这里不包括nova-compute，因为Controller节点不负责运行虚拟机。Nova是个至关重要的组件，也是个相对庞大的组件，其中有很多服务，它是进行生成虚拟机工作的主要服务。

Cinder（除去Cinder-volume的其他组件）：用来创建、删除及管理volume（虚拟磁盘卷），以及给volume做快照等服务的组件。

Horizon：OpenStack的Web管理页面，使用Django框架开发。Web管理页面包含了日常使用的大部分功能，提供给用户一个最直观的展现方式。很多简单的二次开发工作都是从Horizon开始的。

1.系统环境准备

在安装部署OpenStack之前，首先需要做一些安装额外软件和配置网络等准备，主要包括以下几个部分：

· 操作系统为Ubuntu 12.04 LTS，最小化安装即可。在安装系统的时候，安装opensshserver，分区尽量能有30GB空间，用来完成这个测试环境。

· 网络连接和IP设置。需要两个以太网口，分配两个独立的网络。

· 添加OpenStack Havana版本的软件包源到系统中，并且更新系统。

· 安装NTP服务。

· MySQL，安装MySQL数据库和Python的MySQL库。

· RabbitMQ，安装Rabbitmq-server作为OpenStack的AMQP。

（1）网络IP配置

按照架构的设计，controller需要两个网口，连接两个网段。

· eth0所在的网段是一个用户可访问的网段，在本章中，把这个网络命名为network-1，将会通过Web访问这个eth0所使用的IP来进行登录Web的操作。举例来说，如果笔者现在的PC配置的IP是10.10.101.10，22位的掩码，那么笔者的controller的eth0可以配置为10.10.101.10/22这个网段中任何没有使用的IP地址。

· eth1所在的网段是一个私有的管理网段，在本章中，把这个网络命名为network-2。在实际环境中，所有的节点，无论是controller，还是计算节点，网络节点都需要有一个网口连接这个网段，所有的数据库连接，以及RabbitMQ的通信使用的都是这个网口。如果用SSH登录来进行修改配置等工作，也应接入这个网段进行操作。如果需要监控OpenStack环境中的服务器和虚拟机，也建议通过接入这个网段进行。这个网段不需要有能访问外部网络的功能。在一个简单的模型中，只要把这些网口接入到一台交换机上即可，示例如下所示：

# cat /etc/network/interfaces
# network-1 Internet
auto eth0
iface eth0 inet static
address 10.10.101.10
netmask 255.255.252.0
network 10.10.100.0
broadcast 10.10.103.255
gateway 10.10.100.1
dns-nameservers 8.8.8.8
# network-2 Management
auto eth1
iface eth1 inet static
address 10.80.80.10
netmask 255.255.255.0

以上是笔者环境中的网络配置文件，读者可以根据自己环境的实际情况进行修改，然后重启服务器网络。命令如下，提示符#的命令操作表示是在root用户环境下进行的操作。

# /etc/init.d/networking restart

（2）添加Havana的源

Ubuntu 12.04默认的OpenStack的版本是Essex版本，如果不安装其他版本的源，那么默认命令安装的都是Essex版本的软件包，这点需要用户注意。此处，要加入OpenStack软件包的Havana的源，然后更新一下系统的软件包信息和已安装的软件。命令如下：

# apt-get install –y python-software-properties
# add-apt-repository cloud-archive：avana

加入新的源后会在/etc/apt/sources.list.d/目录下多出一个Havana源的文件，如下所示：

# apt-get update
# apt-get upgrade –y
# apt-get dist-upgrade –y

更新完系统后可以重启，也可以等安装完OpenStack后再重启。

（3）安装NTP服务

在整个OpenStack集群中，规模可以从几个节点到几十个节点，甚至几百个，为了保证这些集群中的节点互相通信正常，需要使各个节点的时间一致，误差不能太大，因此需要一台NTP服务器来提供时间同步，在这个测试环境中，选择在控制节点上安装NTP服务。命令如下：

# apt-get install –y ntp

（4）安装MySQL数据库

OpenStack的主要组件都需要数据库的支持。OpenStack支持MySQL、PostgreSQL、SQLite。在这个测试环境中，选择MySQL作为数据库。控制端安装MySQL的Server，节点通过Python的MySQL客户端模块连接到MySQL Server。命令如下：

# apt-get install –y mysql-server python-mysqldb

提示

安装MySQL的过程中，会提示创建MySQL的root密码。

默认MySQL只监听127.0.0.1，而在实际的生产环境中，出于安全考虑，数据库通信经过的是管理网段，只需让MySQL监听管理网的IP。在这个安装实例中，可以将管理网IP设置为10.80.80.10。重启MySQL使配置生效。代码如下：

# sed –I"s/127.0.0.1/10.80.80.10/" /etc/mysql/my.cnf
# service mysql restart

（5）安装Messaging服务

OpenStack组件之间的通信需要通过支持AMQP的Messaging服务软件。OpenStack支持的有RabbitMQ、Qpid和ZeroMQ。这里安装RabbitMQ。命令如下：

# apt-get install -y rabbitmq-server

安装RabbitMQ服务软件时，RabbitMQ默认用户guest的密码是guest，出于安全考虑，用户可以在实际环境中更改密码。如果用户的RabbitMQ启动失败，那么可能是由于/ etc/hosts中127.0.0.1所对应的主机名和使用命令hostname后的结果不一致，此时可以尝试在/etc/hosts的localhost前面把hostname加入，然后再启动RabbitMQ。修改guest密码的命令是：

# rabbitmqctl change_password guest NEW_PASSWORD

至此，前置工作已经完成，下面可以开始安装OpenStack了。

2.安装部署Keystone

把Keystone作为安装OpenStack的第一步，因为它是整个OpenStack的认证系统，就好比屋子的一扇门，只有通过了这扇门，才能进行后面的操作。另外，Keystone负责OpenStack的用户管理，只有创建了用户，才能以这个用户的身份进入这扇门。

安装配置Keystone的过程主要分为下面几步：

· 安装软件包和修改配置文件。

· 创建Keystone的数据库，并建立Keystone的表结构。

· 启动服务，确认服务正常运行。验证Keystone可以使用。

· 创建Keystone的管理员用户。

· 定义Keystone使用的Services和API Endpoints。

· 以创建的用户来使用Keystone客户端命令行。

（1）安装和配置Keystone

直接安装Keystone一个包即可，系统同时会自动安装Python-keystoneclient的客户端包，其命令如下：

# apt-get install -y keystone

Keystone的配置文件放在/etc/keystone目录下，要修改的主要是keystone.conf这个文件。主要修改以下几个参数：

# vi /etc/keystone/keystone.conf
admin_token = openstack
debug = True
verbose = True
connection = mysql：//keystoneuser：openstack@localhost/keystone

· admin_token：这个选项至关重要，可以将其比喻成获取Keystone管理权限的“钥匙”。在这里可以设置一个复杂的字符串，因为太简单的字符串容易被破解。由于是测试环境，笔者就用openstack这个字符串作为admin的token。此时，因为在Keystone中还未建立任何用户，所以这个token和用户无关，但是这个token在生产环境中需要足够复杂且绝对保密。

· debug与verbose：这两个选项均设置为True，用于测试时查看详细的输出信息，而输出信息会保存在log_dir和log_file定义的目录文件中。

· connection：这个选项定义Keystone使用的数据库的URL。这里用了MySQL的keystoneuser用户，密码是openstack，数据库地址是localhost，也就是本机，数据库名是keystone。注意，目前我们还没有建立这个数据库和数据库用户。

在这个测试环境中，保持配置文件中其他选项不变。

（2）Keystone的数据库操作

需要在MySQL中建立一个Keystone的数据库，再创建一个用户，赋予其对keystone数据库的操作权限，代码如下。注意，建立的数据库名、用户名及密码要和上面keystone.conf配置文件中的connection选项一致。

# mysql -uroot -p -e "CREATE DATABASE keystone;"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON keystone.* TO'keystoneuser'@
    'localhost'IDENTIFIED BY 'openstack';"

建立好的数据库是空的，需要初始化Keystone数据库的表结构。Keystone提供了一个很方便的创建结构的命令：

# keystone-manage db_sync

运行成功之后，可以进入MySQL查看Keystone这个数据库的表结构和字段。

（3）确认Keystone服务正常运行

配置文件修改后需要重启服务：

# service keystone restart

如何确认Keystone服务正常启动？根据笔者的经验，可以从几个方面入手，这个也是后面经常会使用的方法。

· 使用命令“service keystone status”查看keystone进程是否为running状态。

· 查看log文件。log文件被定义在keytone.conf中，默认是/var/log/keystone/keystone.log，查看是否有出错日志。如果设置了debug和verbose为True，那么信息会很详细，有利于排错。

· 调用命令“keystone client”。其实前两步是查看服务是否正常启动，真正确认还需要第三步，即排错。服务启动了并不代表Keystone能如用户所愿地进行工作，有时配置选项设置成不同的参数，服务也能正常运行，但是使用Keystone的时候会出错，因此，运行一个实际的命令来验证Keystone是否能正常工作。运行命令前首先要输入token和Keystone的endpoint：

# export OS_SERVICE_TOKEN=openstack
# export OS_SERVICE_ENDPOINT=http：//127.0.0.1：35357/v2.0/
# keystone user-list

前面两行是设定token和endpoint的环境变量。可以把它放入一个文件里，然后每次使用OpenStack之前只要执行“source这个文件”即可。还记得前面在Keystone配置文件中的一个选项admin_token吗？这里的第一个token使的就是当时设定的那个值。第三行命令是测试Keystone是否能正常运行，需要列出Keystone中的用户。输出是一个空行？不用担心，这是正常运行的表现，至少没有报错信息。运行命令的时候，建议结合日志的方法，再打开一个窗口使用命令tail日志文件，查看是否有报错情况。因为到目前为止还没有建立过用户，所以肯定没有用户使用的使用Keystone服务的日志。

（4）创建第一个Keystone用户

接下来的部分可能有点烦琐和难以理解，但笔者不打算在这里详细讲解每条命令的意思，也不会说明为什么要这样做。这些原理性的内容将在第5章详细讲解。这里的任务是快速地把基本环境搭起来，如果读者对这部分的内容产生疑惑，可以先照着步骤去做，相信等有了一个完整可用的体系后，在使用中会慢慢理解其中的含义。

这里将建立一个用户、一个tenant和一个role，它们之间的关系是用户属于tenant，用户在tenant中可以有不同的角色。记住，操作之前一定要设置token和endpoint这两个环境变量。

首先，创建一个具有管理权限的tenant，称为admin，其代码如下：

# keystone tenant-create --name=admin
+-------------+----------------------------------+
|   Property  |             Value                |
+-------------+----------------------------------+
| description |                                  |
|   enabled   |              True                             |
|      id     | 08cbb73f6689477eb42d7be9a901e55c |
|     name    |              admin                            |
+-------------+----------------------------------+

然后，创建一个用户，命名为admin，密码设置为openstack，其代码如下：

# keystone user-create --name=admin --pass="openstack"
+----------+----------------------------------+
| Property |              Value               |
+----------+----------------------------------+
|  email   |                                  |
| enabled  |               True               |
|    id    | 3372c9032dd24ee9b2dcefcdbba13f01 |
|   name   |              admin               |
+----------+----------------------------------+

接着，创建一个称为admin的角色，其代码如下：

# keystone role-create --name=admin
+----------+----------------------------------+
| Property |              Value               |
+----------+----------------------------------+
|    id    | 59aa2c3dcbf542d1a84e6703eb45d8b1 |
|   name   |              admin               |
+----------+----------------------------------+

最后，把前面创建的tenant、用户和role组合起来，在admin的tenant中分配admin的角色给用户admin，命令如下：

# keystone user-role-add --user admin --role admin --tenant admin

（5）定义Services和API Endpoints

为了使用Keystone来认证用户使用的OpenStack中的其他组件，需要在Keystone中创建组件的服务和相应的API Endpoints，组件服务的API Endpoints是一组URL加端口号，用来提供组件服务的API接口。

这里需要创建一个Keystone的服务和Keystone的API Endpoints，其代码如下：

# keystone service-create --name keystone --type identity --description
    'OpenStack Identity'
+-------------+----------------------------------+
|   Property  |              Value               |
+-------------+----------------------------------+
| description |        OpenStack Identity        |
|      id     | 6660f592f4884e7ca18d498e7aa130a1 |
|     name    |          keystone                |
|     type    |          identity                |
+-------------+----------------------------------+
# keystone endpoint-create --service-id 6660f592f4884e7ca18d498e7aa130a1 --publicurl
'http：//10.10.101.10：5000/v2.0' --adminurl
'http：//10.80.80.10：35357/v2.0' --internalurl
'http：//10.80.80.10：5000/v2.0'
+-------------+----------------------------------+
|   Property  |                 Value            |
+-------------+----------------------------------+
|   adminurl  |  http：//10.80.80.10：35357/v2.0 |
|      id     | 2dee1b06cbda4d8095c344ab3671d0ce |
| internalurl |   http：//10.80.80.10：5000/v2.0 |
|  publicurl  |  http：//10.10.101.10：5000/v2.0 |
|    region   |              regionOne           |
|  service_id | 6660f592f4884e7ca18d498e7aa130a1 |
+-------------+----------------------------------+

endpoint-create命令中的service id是service-create命令得到的ID号。publicurl里面的IP使用对外是可以访问的。adminurl和internalurl使用内部管理的IP，当然这个也可以视实际情况而定。

（6）使用Keystone命令行客户端

使用命令行客户端需要通过认证，有以下两种认证的方式。

· 使用keystone.conf配置文件中的token认证，设置以下两个环境变量：

# export OS_SERVICE_TOKEN=openstack
# export OS_SERVICE_ENDPOINT=http：//127.0.0.1：35357/v2.0/

· 使用在Keystone中创建的用户名及密码进行认证，设置以下环境变量：

export OS_TENANT_NAME=admin
export OS_USERNAME=admin
export OS_PASSWORD=openstack
export OS_AUTH_URL="http：//192.168.5.101：5000/v2.0/"

其中填入需要认证用户的tenant、用户名和密码，最后一个是认证的URL，仔细观察和Keystone的endpoint中的publicurl的关系。

第一种方式通过设置OS_SERVICE_TOKEN和OS_SERVICE_ENDPOINT来认证，适用于Keystone中还没有管理员权限的用户的情况。现在我们有了一个管理员用户，就应该通过用户登录，而不是使用token。需要取消OS_SERVICE_TOKEN和OS_SERVICE_ ENDPOINT这两个变量，然后再导入用户的认证。如果同时设置了两种方式，那么系统会有一个忽略用户认证的警告，仍旧使用token的认证。命令如下：

# unset OS_SERVICE_TOKEN
# unset OS_SERVICE_ENDPOINT

可以把认证方式的变量写在一个文件中，这里命令为openstackrc，在以后每次使用的时候，导入以下文件即可。

# source openstackrc
# keystone user-list
+----------------------------------+-------+---------+-------+
|                id                |  name | enabled | email |
+----------------------------------+-------+---------+-------+
| 3372c9032dd24ee9b2dcefcdbba13f01 | admin |   True  |       |
+----------------------------------+-------+---------+-------+

3.安装Glance镜像组件

Glance组件完成镜像模板snapshot的存储工作。Glance主要包括了glance-api和glaneregistry两个服务，其安装和配置都比较简单，主要分为以下几步：

· 安装软件包，编辑配置文件。

· 创建Glance的数据库。

· 在Keystone中，创建Glance的用户、服务和Endpoint。

· 初始化Glance数据库，启动服务，确认服务正常运行。

· 在Glance中添加虚拟机镜像。

（1）安装软件包，编辑配置文件

安装Glance服务时，将把glance-api、glance-registry、python-glanceclient都安装上。安装命令如下：

# apt-get install -y glance

Glance的配置默认文件在/etc/glance下，需要修改如下内容。

glance-api.conf的修改如下：
[DEFAULT]
verbose = True
debug = True
sql_connection = mysql：//glanceuser：openstack@localhost/glance
[keystone_authtoken]
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = glance
admin_password = openstack
[paste_deploy]
flavor=keystone

glance-registry.conf的修改如下：

[DEFAULT]
verbose = True
debug = True
sql_connection = mysql：//glanceuser：openstack@localhost/glance
[keystone_authtoken]
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = glance
admin_password = openstack
[paste_deploy]
flavor=keystone

（2）创建Glance数据库

根据上面配置文件中设定的sql_connection，在数据库中创建用户名为glanceuser，密码为openstack。创建数据库glance，赋予glanceuser对数据库glance的所有权限，其代码如下：

    # mysql -uroot -p -e "CREATE DATABASE glance;"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON glance.* TO
    'glanceuser'@'localhost'IDENTIFIED BY 'openstack';"

（3）在Keystone中，创建Glance的用户、服务和Endpoint

在这个测试安装中，Glance需要通过Keystone来进行用户的身份认证。我们已经在前面的glance-api和glance-registry配置文件中设置了认证的用户等，现在必须在Keystone中创建用户glance，加入service这个tenant，赋予admin的角色，其代码如下：

# keystone tenant-create --name=service
# keystone user-create --name=glance --pass=openstack
# keystone user-role-add --user glance --role admin --tenant service

在Keystone通过用户验证后，因为需要知道Glance的服务和Endpoint API，所以必须在Keystone创建，其代码如下：

# keystone service-create --name glance --type image --description'OpenStack
    Image Service'
+-------------+----------------------------------+
|   Property  |              Value               |
+-------------+----------------------------------+
| description |     OpenStack Image Service      |
|      id     | 7bedcd5298d5404bbc82219f61372c1d |
|     name    |              glance              |
|     type    |              image               |
+-------------+----------------------------------+
# keystone endpoint-create --service-id
    7bedcd5298d5404bbc82219f61372c1d –publicurl
    'http：//10.10.101.10：9292'--adminurl
    'http：//10.80.80.10：9292/' --internalurl
    'http：//10.80.80.10：9292/'
+-------------+----------------------------------+
|   Property  |                Value             |
+-------------+----------------------------------+
|   adminurl  |       http：//10.80.80.10：9292/ |
|      id     | b44b36a8c8c5406887f3d0a6d819b57d |
| internalurl |       http：//10.80.80.10：9292/ |
|  publicurl  |       http：//10.10.101.10：9292 |
|    region   |                regionOne         |
|  service_id | 7bedcd5298d5404bbc82219f61372c1d |
+-------------+----------------------------------+

提示

两条命令的service id必须一致。

（4）初始化Glance数据库，启动服务，确认服务正常运行

使用glance-manage命令，初始化glance数据库，其命令如下：

# glance-manage db_sync

重启服务，查看/var/log/glance目录下的日志文件，确保启动后没有出错信息。也可以在glance-api.conf和glance-registry.conf中设置debug和verbose为True，来得到更多的日志信息。重启代码如下：

# service glance-api restart
# service glance-registry restart

最后，确认一下服务是否运行，其代码如下：

# service glance-api status
# service glance-registry status
# glance image-list

（5）在Glance中添加虚拟机镜像

到此为止，Glance的环境已经搭建好，但是Glance中还没有可用的镜像，只是可以用来启动虚拟机的模板。模板可以自己创建，具体创建的方法将会在第6章详细介绍。在这个测试安装中，为了方便，使用网络上一个精简的可启动的Linux系统作为模板。首先下载这个小镜像，其代码如下：

# wget http：//download.cirros-cloud.net/0.3.1/cirros-0.3.1-x86_64-disk.img

使用Glance命令行客户端把镜像添加到Glance中。Glance会在数据库中记录，并把文件复制到指定的目录，其代码如下：

# glance image-create --name myFirstImage --is-public true --container-format bare
    --disk-format qcow2 --file cirros-0.3.1-x86_64-disk.img

再次运行“glance image-list”命令查看已上传的镜像，其代码如下：

# glance image-list
+--------------------------------------+--------------+-------------+------------------+----------+--------+
| ID | Name | Disk Format | Container Format | Size | Status |
+--------------------------------------+--------------+-------------+------------------+----------+--------+
| d56d2ae1-2f8e-4801-ac06-b9e0ce7af6da | myFirstImage | qcow2 | bare| 13147648 | active |
+--------------------------------------+--------------+-------------+------------------+----------+--------+

4.安装Neutron网络组件

Neutron在整个OpenStack中负责网络部分的功能，其实Neutron仅仅只有管理功能，实际的网络方面的实现依靠的是更加底层的网络技术，譬如Linux网桥、Open vSwitch和Nicira等，在Neutron中，这些网络技术以plugin的形式使用。因此，在各个节点上，需要安装Neutron的不同服务，才能形成一个真正的网络组件。

提示

在Grizzly版本发布以后，网络组件改名为Neutron，以前叫做Quantum，因此，当看到有的文档或者安装过程提到Quantum的时候，其实指的就是Neutron。

在控制节点上，需要主要进行以下几个步骤：

· 安装neutron-server服务，修改配置文件。

· 在Keystone中创建用户、服务和Endpoint。

· 在MySQL中创建数据库和用户。

（1）安装软件包，修改配置文件

Neutron的软件包按照功能可以划分为多个，在控制节点，只需要安装neutron-server的服务。同时，依赖会安装neutron-plugin-openvswitch。其代码如下：

# apt-get install -y neutron-server

修改配置文件，主要是设定Keystone认证和Neutron数据库，其代码如下：

# vi /etc/neutron/neutron.conf[keystone_authtoken]
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = neutron
admin_password = openstack
signing_dir = $state_path/keystone-signing
[database]
connection = mysql：//neutronuser：openstack@localhost/neutron
[DEFAULT]
# 如果用户设置了RabbitMQ的默认guest密码，那么必须去掉这一行的注释，写入自己设定的密码rabbit_password = guest

ovs_neutron_plugin.ini配置文件代码如下：

# vi /etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini
[OVS]
tenant_network_type = gre
enable_tunneling = True
tunnel_type = gre
tunnel_id_ranges = 1：1000
[securitygroup]
firewall_driver = neutron.agent.linux.iptables_firewall.OVSHybridIptablesFirewallDriver
[database]
connection = mysql：//neutronuser：openstack@10.80.80.10/neutron

（2）创建用户、服务和Endpoint

在Keystone中创建用户、服务和Endpoint，其代码如下：

# keystone user-create --name=neutron --pass=openstack
# keystone user-role-add --user neutron --role admin --tenant service
# keystone service-create --name neutron --type network --description
    'OpenStack Networking service'
+-------------+----------------------------------+
|   Property  |              Value               |
+-------------+----------------------------------+
| description |   OpenStack Networking service   |
|      id     | 7dc990a812874042bc96a1ca983ede1a |
|     name    |             neutron              |
|     type    |             network              |
+-------------+----------------------------------+
# keystone endpoint-create --service-id 7dc990a812874042bc96a1ca983ede1a --publicurl
    'http：//10.10.101.10：9696/' --adminurl
    'http：//10.80.80.10：9696/' --internalurl
    'http：//10.80.80.10：9696/'
+-------------+----------------------------------+
|   Property  |                 Value            |
+-------------+----------------------------------+
|   adminurl  |     http：//10.80.80.10：9696/   |
|      id     | 1b67e73564fc4f6087fd90aed723d8a4 |
| internalurl |     http：//10.80.80.10：9696/   |
|  publicurl  |     http：//10.10.101.10：9696/  |
|    region   |               regionOne          |
|  service_id | 7dc990a812874042bc96a1ca983ede1a |
+-------------+----------------------------------+

（3）创建Neutron数据库和用户

因为Neutron的数据库会被其他节点连接，所以必须赋予Neutron数据库用户相应的权限，使neutronuser不但能从本机连接，还要能从节点机器上连接控制服务器上的数据库，其代码如下：

# mysql -uroot -p -e "CREATE DATABASE neutron;"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON neutron.* TO
    'neutronuser'@'%'IDENTIFIED BY'openstack';"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON neutron.* TO'neutronuser'@
    'localhost'IDENTIFIED BY'openstack';"

5.安装Nova组件

Nova项目中虽然包含了很多组件，但是要在控制服务器上安装除去nova-compute的其他一切Nova组件。其过程主要分为下面几步：

· 安装Nova软件包，设置Nova配置文件。

· 创建数据库，初始化Nova数据库。

· 在Keystone中创建Nova用户和Endpoint。

1）安装Nova软件包，并配置相应文件，命令如下：

# apt-get install -y nova-api nova-cert novnc nova-consoleauth nova-scheduler
    nova-novncproxy nova-doc nova-conductor

Nova的配置文件放在/etc/nova目录下，这次安装中需要修改的是api-paste.ini和nova.conf这两个文件。

api-paste.ini中要修改的是认证部分，其代码如下：

# vi /etc/nova/api-paste.ini
[filter：authtoken]
paste.filter_factory = keystoneclient.middleware.auth_token：filter_factory
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = nova
admin_password = openstack
signing_dir = /var/lib/nova/keystone-signing
auth_version = v2.0

Nova几乎全部的配置都是写在nova.conf中的，其中选项参数很多，这里，笔者将列出一份测试环境安装使用的nova.conf配置文件以供参考。

    # vi /etc/nova/nova.conf
[DEFAULT]
logdir=/var/log/nova
state_path=/var/lib/nova
lock_path=/run/lock/nova
verbose=True
debug=True
api_paste_config=/etc/nova/api-paste.ini
compute_scheduler_driver=nova.scheduler.simple.SimpleScheduler
rabbit_host=10.80.80.10
rabbit_password=guest
nova_url=http：//10.80.80.10：8774/v1.1/
sql_connection=mysql：//novauser：openstack@10.80.80.10/nova
root_helper=sudo nova-rootwrap /etc/nova/rootwrap.conf
enabled_apis=ec2,osapi_compute,metadata
# Auth
use_deprecated_auth=false
auth_strategy=keystone
# Imaging service
glance_api_servers=10.80.80.10：9292
image_service=nova.image.glance.GlanceImageService
# Vnc configuration
novnc_enabled=true
novncproxy_base_url=http：//10.10.101.10：6080/vnc_auto.html
novncproxy_port=6080
vncserver_proxyclient_address=10.80.80.10
vncserver_listen=10.80.80.10
# Network settings
network_api_class=nova.network.neutronv2.api.API
neutron_url=http：//10.80.80.10：9696
neutron_auth_strategy=keystone
neutron_admin_tenant_name=service
neutron_admin_username=neutron
neutron_admin_password=openstack
neutron_admin_auth_url=http：//10.80.80.10：35357/v2.0
    libvirt_vif_driver=
        nova.virt.libvirt.vif.LibvirtHybridOVSBridgeDriver
    linuxnet_interface_driver=
        nova.network.linux_net.LinuxOVSInterfaceDriver
#If you want Quantum + Nova Security groups
firewall_driver=nova.virt.firewall.NoopFirewallDriver
security_group_api=neutron
#If you want Nova Security groups only, comment the two lines above and
    uncomment line -1-.
#-1-firewall_driver=
nova.virt.libvirt.firewall.IptablesFirewallDriver
#Metadata
service_neutron_metadata_proxy = True
neutron_metadata_proxy_shared_secret = openstack
metadata_host = 10.80.80.10
metadata_listen = 0.0.0.0
metadata_listen_port = 8775
# Compute #
#compute_driver=libvirt.LibvirtDriver
# Cinder #
volume_api_class=nova.volume.cinder.API
osapi_volume_listen_port=5900
# Quota #
quota_cores=5
quota_floating_ip3=3
quota_gigabytes=20
quota_driver=nova.quota.DbQuotaDriver
quota_instances=5
quota_key_pairs=2
quota_ram=51200
quota_volumes=2

2）创建并初始化Nova数据库，命令如下：

# mysql -uroot -p -e "CREATE DATABASE nova;"

因为Nova数据库也需要其他节点连接，所以必须赋予从localhost和其他节点连接的权限，代码如下：

# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON nova.* TO novauser@'%' IDENTIFIED BY
    'openstack';"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON nova.* TO novauser@'localhost'
    IDENTIFIED BY'openstack';"

初始化Nova数据库的表结构：

# nova-manage db sync

修改配置文件和初始化数据库后，需要重启Nova所有安装的服务，其代码如下：

# cd /etc/init.d/; for i in $( ls nova-* ); do sudo service $i restart; done

用如下命令查看Nova服务的状态，：-）表示服务运行，XXX表示服务停止。也可以查看/var/log/nova下的各个日志文件是否有出错日志。如果有出错日志和XXX显示，那么必须排查错误。错误很可能出现在nova.conf配置文件上。在进行下一步前，必须确保服务正常运行，其代码如下：

# nova-manage service list

3）在Keystone中创建Nova用户和Endpoint，示例如下：

# keystone user-create --name=nova --pass=openstack
# keystone user-role-add --user nova --role admin --tenant service
# keystone service-create --name nova --type compute --description'OpenStack
    Compute Service'
+-------------+----------------------------------+
|   Property  |              Value               |
+-------------+----------------------------------+
| description |    OpenStack Compute Service     |
|      id     | bc4873dd598a4f23a2a61b225914efe4 |
|     name    |               nova               |
|     type    |             compute              |
+-------------+----------------------------------+
# keystone endpoint-create --service-id bc4873dd598a4f23a2a61b225914efe4 –publicurl
    'http：//10.10.101.10：8774/v2/$(tenant_id)s' --adminurl
    'http：//10.80.80.10：8774/v2/$(tenant_id)s' --internalurl
    'http：//10.80.80.10：8774/v2/$(tenant_id)s'
+-------------+-------------------------------------------+
|   Property  |                      Value |
+-------------+-------------------------------------------+
|   adminurl  |  http：//10.80.80.10：8774/v2/$(tenant_id)s |
|      id     |      e15110d5150247ef88f126ad2ea445ed      |
| internalurl |  http：//10.80.80.10：8774/v2/$(tenant_id)s |
|  publicurl  | http：//10.10.101.10：8774/v2/$(tenant_id)s |
|    region   |                   regionOne                |
|  service_id |        bc4873dd598a4f23a2a61b225914efe4    |
+-------------+-------------------------------------------+

运行Nova的客户端命令，列出当前可用的镜像，测试是否能正常运行，其代码如下：

# nova image-list
+--------------------------------------+--------------+--------+--------+
| ID                                   | Name         | Status | Server |
+--------------------------------------+--------------+--------+--------+
| aae5f478-a8d4-4f56-8fb6-03c8e849f009 | myFirstImage | ACTIVE |        |
+--------------------------------------+--------------+--------+--------+

6.安装Cinder

Cinder有三个组件服务：cinder-api、cinder-scheduler、cinder-volume。要在控制节点上安装cinder-api和cinder-scheduler，其中cinder-api负责接收其他组件或命令对cinder-volume的请求，而cinder-scheduler则是Cinder的调度程序，调度使用哪个volume。

（1）安装和配置

命令如下：

# apt-get install -y cinder-api cinder-scheduler

配置Keystone认证文件，其代码如下：

# vi /etc/cinder/api-paste.ini
[filter：authtoken]
paste.filter_factory = keystoneclient.middleware.auth_token：filter_factory
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = cinder
admin_password = openstack
signing_dir = /var/lib/cinder/keystone-signing
# vi /etc/cinder/cinder.conf
[DEFAULT]
rootwrap_config = /etc/cinder/rootwrap.conf
api_paste_confg = /etc/cinder/api-paste.ini
iscsi_helper = tgtadm
volume_name_template = volume-%s
volume_group = cinder-volumes
verbose = True
auth_strategy = keystone
state_path = /var/lib/cinder
lock_path = /var/lock/cinder
volumes_dir = /var/lib/cinder/volumes
rabbit_password = guest
[database]
connection = mysql：//cinderuser：openstack@localhost/cinder

（2）创建数据库和Keystone用户

创建和cinder.conf中connection变量一致的数据库用户名及密码，其代码如下：

# mysql -uroot -p -e "CREATE DATABASE cinder;"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON cinder.* TO cinderuser@'localhost'
    IDENTIFIED BY 'openstack';"
# mysql -uroot -p -e "GRANT ALL PRIVILEGES ON cinder.* TO cinderuser@'%'
    IDENTIFIED BY 'openstack';"

初始化数据库cinder表结构：

# cinder-manage db sync

在Keystone中添加cinder用户和服务的Endpoint，其代码如下：

# keystone user-create --name=cinder --pass=openstack
# keystone user-role-add --user cinder --role admin --tenant service
# keystone service-create --name=cinder --type=volume --description="Cinder
    Volume Service"
+-------------+----------------------------------+
|   Property  |              Value               |
+-------------+----------------------------------+
| description |       Cinder Volume Service      |
|      id     | fd43556d811a4822a615a75928d5969d |
|     name    |              cinder              |
|     type    |              volume              |
+-------------+----------------------------------+
# keystone endpoint-create --service-id=fd43556d811a4822a615a75928d5969d
    --publicurl=http：//10.80.80.10：8776/v1/%\(tenant_id\)s --internalurl=
    http：//10.80.80.10：8776/v1/%\(tenant_id\)s --adminurl=
    http：//10.80.80.10：8776/v1/%\(tenant_id\)s

重启Cinder服务，其代码如下：

# service cinder-api restart
# service cinder-scheduler restart

可以使用命令查看Cinder服务的状态，其代码如下：

# cinder-manage service list
Binary           Host                                     Zone              Status
    State Updated At
cinder-scheduler controller nova enabled
    ：-)  2013-11-25 13：16：09

7.安装Horizon

Horizon是OpenStack的一个Dashboard，也就是以网页形式面向用户的一个界面。通过Horizon，用户可以很方便地使用OpenStack，而不必使用烦琐的命令行。安装OpenStack的Dashboard的过程很简单，其命令如下：

# apt-get install -y openstack-dashboard memcached

安装好以后，就可以使用Web浏览器了，这里建议使用Chrome访问http：//10.80.80.10/ horizon。此处暂时可以使用用户名admin和密码OpenStack进行登录。这个界面是Ubuntu包装过的，如果想要用Horizon原来的界面，可以去除Ubuntu的界面，代码如下：

# dpkg --purge openstack-dashboard-ubuntu-theme
# service apache2 restart; service memcached restart

至此，可以打开Web浏览器，在地址栏里输入http：//10.80.80.10/horizon，其中IP地址需更换成用户实际环境中的。此时，会看到OpenStack登录界面，使用用户名admin和密码OpenStack进行登录，如图2-2所示。

图2-2 OpenStack登录界面

在Keystone中创建Member角色，因为Horizon中会用到这个角色，其代码如下：

# keystone role-create --name Member

2.1.2 网络节点的安装

网络节点主要负责虚拟机的网络控制，包括DHCP、虚拟路由、公网访问虚拟机等。通过软件网桥等方式控制虚拟机的网络，代替传统环境中所需要的交换机、路由器等。在这个测试案例中，使用Open vSwitch作为底层的网络驱动。

1.系统环境准备

操作系统仍旧使用Ubuntu 12.04 LTS。网络节点需要三个网口，分别连接network-1、network-2、network-3，前两个网络在控制节点安装的时候定义过，而network-3是个新网络，是个私有的网络，IP网段自定义，它需要和所有的计算节点通信，因此，可以和计算节点连在一个交换机上或者VLAN中。

（1）网络IP设置

· eth0在前面定义的network-1网络中，这个网络连接Internet。计算节点中的虚拟机出入Internet的流量都从这里经过。

· eth1在前面定义的network-2网络中。这个接入管理网络的网口主要负责和controller之间的组件通信，包括所有的数据库连接、RabbitMQ等。

· eth2在新定义的网络中，命名为network-3。这个网络和所有的计算节点连接，用于Open vSwitch的GRE隧道，使得虚拟机能和网络节点通信。代码如下：

# cat /etc/network/interfaces
# network-1 Internet
auto eth0
iface eth0 inet static
    address 10.10.101.11
    netmask 255.255.252.0
    network 10.10.100.0
    broadcast 10.10.103..255
    gateway 10.10.100.1
    dns-nameservers 8.8.8.8
# network-2 Management
auto eth1
iface eth1 inet static
    address 10.80.80.11
    netmask 255.255.255.0
# network-3 vm
auto eth2
iface eth2 inet static
    address 10.10.50.1
    network 255.255.255.0

重启网络，命令如下：

# /etc/init.d/networking restart

（2）添加Havana的源

添加Havana的源，代码如下：

# apt-get install -y python-software-properties
# add-apt-repository cloud-archive：havana
# apt-get update -y
# apt-get upgrade -y
# apt-get dist-upgrade -y

更新完系统之后，可以根据实际情况重启服务器。

（3）同步时间

同步时间的命令如下：

# apt-get install -y ntp
# vi /etc/ntp.conf

编辑ntp.conf，在控制节点的IP中加入下面的一行，并且放在所有“server ntp服务器域名”的行之前，或者删除其他关于server ntp服务器的行。

server 10.80.80.10

重启NTP服务，命令如下：

# service ntp restart

打开IP转发的功能，因为网络节点需要把从vm网络来的数据包转发到Internet，其代码如下。

# sysctl net.ipv4.ip_forward=1

写入配置文件，使得重启后仍旧生效，命令如下。

# vi /etc/sysctl.coof
net.ipv4.ip_forward = 1

2.安装Open vSwitch和Neutron

由于采用Open vSwitch作为Neutron的plugin来实现底层的网络虚拟化，因此需要安装Open vSwitch。在Open vSwitch中添加两个虚拟网络交换机：br-int、br-ex，其代码如下：

# apt-get install -y openvswitch-switch openvswitch-datapath-dkms
# ovs-vsctl add-br br-int
# ovs-vsctl add-br br-ex

在网络节点，需要安装Neutron的大部分组件，这里安装openvswitch-plugin的agent，负责neutron server和plugin之间的相互联系，dhcp-agent负责虚拟网络的DHCP，l3-agent负责虚拟网络的路由和外部连接，另外，还有metadata-agent，其代码如下。

neutron-plugin-openvswitch-agent
neutron-dhcp-agent
neutron-l3-agent
neutron-metadata-agent
    # apt-get -y install neutron-plugin-openvswitch-agent neutron-dhcp-agent
        neutron-l3-agent neutron-metadata-agent

3.配置Neutron的agent

1）全局配置，代码如下：

# vi /etc/neutron/neutron.conf
[DEFAULT]
debug = True
verbose = True
rabbit_host = 10.80.80.10
# 如果修改过rabbit的guest密码，则一定要修改下面一行
rabbit_password = guest

2）Open vSwitch的plugin配置文件，代码如下：

# vi /etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini
[OVS]
tenant_network_type = gre
enable_tunneling = True
tunnel_type = gre
tunnel_id_ranges = 1：1000
integration_bridge = br-int
tunnel_bridge = br-tun
local_ip = 10.10.50.1
[securitygroup]
firewall_driver = neutron.agent.linux.iptables_firewall.OVSHybridIptablesFirewallDriver
[database]
connection = mysql：//neutronuser：openstack@10.80.80.10/neutron

重启服务，命令如下：

# service neutron-plugin-openvswitch-agent restart

3）对metadata-agent进行配置，命令如下：

# vi /etc/neutron/metadata_agent.ini
[DEFAULT]
debug = True
auth_url = http：//10.80.80.10：5000/v2.0

注意

auth_region必须和Keystone中Neutron服务的endpoint一致，默认配置文件里是RegionOne，而Keystone建立endpoint时如果不命名，默认是regionOne，这一个大小写问题曾经让笔者在研究metadata上花了一个下午的时间。

auth_region = regionOne
admin_tenant_name = service
admin_user = neutron
admin_password = openstack
nova_metadata_ip = 10.80.80.10
nova_metadata_port = 8775
metadata_proxy_shared_secret = openstack

重启服务，命令如下：

# service neutron-metadata-agent restart

4）对dhcp-agent进行配置，命令如下：

# vi
[DEFAULT]
debug = True
interface_driver = neutron.agent.linux.interface.OVSInterfaceDriver
dhcp_driver = neutron.agent.linux.dhcp.Dnsmasq
enable_metadata_network = True

重启服务，命令如下：

# service neutron-dhcp-agent restart

5）对l3-agent进行配置，命令如下：

# vi
[DEFAULT]
debug = True
interface_driver = neutron.agent.linux.interface.OVSInterfaceDriver
external_network_bridge = br-ex

重启服务，命令如下：

# service neutron-l3-agent restart

使用“neutron agent-list”命令可以验证目前的Neutron服务。记住，运行命令前必须先导入用户凭证。

4.设置br-ex虚拟网络

前面已经创建了一个br-ex的虚拟交换机，使用命令ifconfig可以看到这个网口。这个虚拟网络是在l3-agent的配置里设置的，简单来说，是用于虚拟机和Internet之间通信的，因此，需要把网络节点上连接Internet的eth0接入到这个br-ex的虚拟交换机上。

提示

运行下面这条命令后， eth0网络会断掉，需确保在配置的时候是通过管理网络接入的，或者是直接在console上执行的。

# ovs-vsctl add-port br-ex eth0

在/etc/network/interfaces中把eth0的网络配置进行修改，如下所示：

auto eth0
iface eth0 inet manual
  up ifconfig $IFACE 0.0.0.0 up
  up ip link set $IFACE promisc on
  down ip link set $IFACE promisc off
  down ifconfig $IFACE down

如果需要让网络节点配置一个可以从这个网络访问的地址，那么可以把原来的eth0的地址配置在br-ex网口上。

2.1.3 计算节点的安装

计算节点主要负责运行虚拟机。在这个测试案例中，使用KVM作为底层的虚拟化技术，OpenStack采用libvirt库来管理KVM。网络使用Open vSwitch来和其他计算节点及网络节点通信。在计算节点上，需要安装以下几个部分：

· Open vSwitch

· neutron-plugin-openvswitch-agent

· nova-compute

· open-iscsi

1.系统环境准备

操作系统仍旧使用Ubuntu 12.04 LTS。网络节点需要两个网口，分别连接network-2和network-3。

1）网络IP设置如下：

# cat /etc/network/interfaces
     # network-2 Management
     auto eth1
     iface eth1 inet static
    address 10.80.80.12
    netmask 255.255.255.0
     # network-3 vm
     auto eth2
     iface eth2 inet static
    address 10.10.50.2
    network 255.255.255.0

· eth1在前面定义的network-2网络中。这个接入管理网络的网口主要负责和controller之间的组件通信，包括所有的数据库连接、RabbitMQ等。

· eth2在前面定义的network-3网络中。这个网络和所有计算节点连接，用于Open vSwitch的GRE隧道，使得虚拟机能和网络节点通信。

重启网络，命令如下：

# /etc/init.d/networking restart

2）添加Havana的源，其代码如下：

# apt-get install -y python-software-properties
# add-apt-repository cloud-archive：havana
# apt-get update -y
# apt-get upgrade -y
# apt-get dist-upgrade -y

更新完系统之后，可以根据实际情况重启服务器。

提示

因为计算节点使用时是不需要公网连接的，也不应该有公网连接，只在安装更新软件时需要连接公共网络，所以可以先保证用户的一个网口可以从公网下载安装软件包，等安装完之后再恢复成内网。

3）同步时间，代码如下：

# apt-get install -y ntp
# vi /etc/ntp.conf

编辑ntp.conf，在控制节点的IP中加入下面一行，并且放在所有“server ntp服务器域名”的行之前，或者删除其他关于server ntp服务器的行。

server 10.80.80.10

重启NTP服务，代码如下：

# service ntp restart

2.安装Open vSwitch和Neutron的plugin

接下来安装Open vSwitch和Neutron的plugin，命令如下：

# apt-get install -y openvswitch-switch openvswitch-datapath-dkms

创建一个用于和内部虚拟机通信的虚拟网络交换机，命令如下：

# ovs-vsctl add-br br-int
# apt-get install -y neutron-plugin-openvswitch-agent

修改配置文件，除了local_ip需要填入计算节点本机的network-3网络的IP之外基本上和网络节点的一样。其代码如下：

# vi /etc/neutron/neutron.conf
[DEFAULT]
debug = True
verbose = True
rabbit_host = 10.80.80.10
# 如果修改过rabbit的guest密码，则一定要修改下面一行
rabbit_password = guest
# vi /etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini
[OVS]
tenant_network_type = gre
enable_tunneling = True
tunnel_type = gre
tunnel_id_ranges = 1：1000
integration_bridge = br-int
tunnel_bridge = br-tun
local_ip = 10.10.50.2
[securitygroup]
firewall_driver = neutron.agent.linux.iptables_firewall.OVSHybridIptablesFirewallDriver
[database]
connection = mysql：//neutronuser：openstack@10.80.80.10/neutron

重启服务，命令如下：

# service neutron-plugin-openvswitch-agent restart

3.安装KVM的虚拟机计算支持

安装KVM的虚拟机计算支持命令如下：

# apt-get install -y nova-compute-kvm

编辑配置文件，加入认证，代码如下：

# vi /etc/nova/api-paste.ini
[filter：authtoken]
paste.filter_factory = keystoneclient.middleware.auth_token：filter_factory
auth_host = 10.80.80.10
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = nova
admin_password = openstack
signing_dir = /var/lib/nova/keystone-signing
auth_version = v2.0

配置Nova文件，可以从控制节点把nova.conf文件的内容复制过来，然后进行修改，主要修改一些涉及IP的地方，其代码如下：

# vi /etc/nova/nova.conf
[DEFAULT]
logdir=/var/log/nova
state_path=/var/lib/nova
lock_path=/run/lock/nova
verbose=True
debug=True
api_paste_config=/etc/nova/api-paste.ini
    compute_scheduler_driver=nova.scheduler.simple.SimpleScheduler
rabbit_host=10.80.80.10
rabbit_password=guest
nova_url=http：//10.80.80.10：8774/v1.1/
    sql_connection=mysql：//novauser：openstack@10.80.80.10/nova
root_helper=sudo nova-rootwrap /etc/nova/rootwrap.conf
enabled_apis=ec2,osapi_compute,metadata
# Auth
use_deprecated_auth=false
auth_strategy=keystone
# Imaging service
glance_api_servers=10.80.80.10：9292
image_service=nova.image.glance.GlanceImageService
# Vnc configuration
novnc_enabled=true
novncproxy_base_url=http：//10.10.101.10：6080/vnc_auto.html
novncproxy_port=6080
vncserver_proxyclient_address=10.80.80.12
vncserver_listen=10.80.80.12
# Network settings
network_api_class=nova.network.neutronv2.api.API
neutron_url=http：//10.80.80.10：9696
neutron_auth_strategy=keystone
neutron_admin_tenant_name=service
neutron_admin_username=neutron
neutron_admin_password=openstack
neutron_admin_auth_url=http：//10.80.80.10：35357/v2.0
    libvirt_vif_driver=nova.virt.libvirt.vif.LibvirtHybridOVSBridgeDriver
    linuxnet_interface_driver=nova.network.linux_net.LinuxOVSInterfaceDriver
#If you want Quantum + Nova Security groups
firewall_driver=nova.virt.firewall.NoopFirewallDriver
security_group_api=neutron
#If you want Nova Security groups only, comment the two lines above and uncomment
    line -1-.
    #-1-firewall_driver=nova.virt.libvirt.firewall.IptablesFirewallDriver
#Metadata
service_neutron_metadata_proxy = True
neutron_metadata_proxy_shared_secret = openstack
# Compute #
#compute_driver=libvirt.LibvirtDriver
# Cinder #
volume_api_class=nova.volume.cinder.API
osapi_volume_listen_port=5900
# Quota #
quota_cores=5
quota_floating_ip3=3
quota_gigabytes=20
quota_driver=nova.quota.DbQuotaDriver
quota_instances=5
quota_key_pairs=2
quota_ram=51200
quota_volumes=2

设置qemu的cgroup文件，代码如下：

# vi /etc/libvirt/qemu.conf
cgroup_device_acl = [
"/dev/null", "/dev/full", "/dev/zero",
"/dev/random", "/dev/urandom",
"/dev/ptmx", "/dev/kvm", "/dev/kqemu",
"/dev/rtc","/dev/hpet", "/dev/vfio/vfio", "/dev/net/tun"
]

重启libvirt服务和nova-compute服务，命令如下：

# service libvirt-bin restart
# service nova-compute restart

2.1.4 块存储节点的安装

块存储节点负责提供volume（云硬盘）。Cinder服务可以在块存储上创建volume，以块存储的形式通过iSCSI提供给计算节点，计算节点使用底层的libvirt库把volume块存储挂载给虚拟机使用。

在控制节点上已经安装了cinder-api和cinder-scheduler，在真正的块存储节点上需要安装cinder-volume的服务，它调度相应程序，在节点上创建或删除volume，并更新维护volume在数据库中的状态。cinder-volume可以使用多种后端来创建块存储，最简单的方式是使用LVM（使用一个vg，然后在这个vg上创建lv作为volume）。我们在测试中也使用LVM的后端。

1.系统环境准备

操作系统仍旧使用Ubuntu 12.04 LTS。网络节点需要一个网口，即network-2。这个网络除了和控制节点进行Rabbit MQ、MySQL数据通信之外，还和计算节点进行iSCSI的数据通信。在实际环境中，所有的虚拟机和云硬盘数据都通过这个网络，可能造成虚拟机读写volume的瓶颈问题，因此，可以考虑使用单独的网络和计算节点连接，必要时可以采取网口绑定或采用10Gbit/s网络。

1）进行网络IP设置，代码如下：

# cat /etc/network/interfaces
auto eth1
iface eth1 inet static
address 10.80.80.13
netmask 255.255.255.0

笔者这样设置是不能连接外网的，但由于需要安装软件，因此读者可以先用其他能连接Internet的网络代替。

2）重启网络，命令如下：

# /etc/init.d/networking restart

3）添加Havana的源，代码如下：

# apt-get install -y python-software-properties
# add-apt-repository cloud-archive：havana
# apt-get update -y
# apt-get upgrade -y
# apt-get dist-upgrade -y

更新完系统之后，可以根据实际情况重启服务器。

4）同步时间，代码如下：

# apt-get install -y ntp
# vi /etc/ntp.conf

编辑ntp.conf，在控制节点的IP中加入下面的一行，并且放在所有“server ntp服务器域名”的行之前，或者删除其他关于server ntp服务器的行。

server 10.80.80.10

2.安装配置cinder-volume

因为使用LVM作为后端，所以必须安装lvm2包。安装命令如下：

# apt-get install lvm2

确保系统中有除了安装系统所在的盘之外的一块单独的硬盘或者使用RAID做的盘。可以使用命令fdisk-l查看。在笔者的环境中，系统安装在/dev/sda中，笔者有额外的一块硬盘/dev/sdb，用它创建一个vg，命名为cinder-volume，其代码如下：

# pvcreate /dev/sdb
# vgcreate cinder-volumes /dev/sdb

安装cinder-volume组件和相关的包，命令如下：

# apt-get -y install cinder-volume python-mysqldb

配置cinder.conf文件，这个文件和控制节点的cinder.conf文件大致相同，唯一不同的是需要改变rabbit_host参数和数据库的connection参数，把其中的IP都设置成控制节点的IP，而在控制节点上的配置文件中，这两个参数的IP可以是localhost。其代码如下：

# vi /etc/cinder/cinder.conf
[DEFAULT]
rootwrap_config = /etc/cinder/rootwrap.conf
api_paste_confg = /etc/cinder/api-paste.ini
iscsi_helper = tgtadm
volume_name_template = volume-%s
volume_group = cinder-volumes
debug = True
verbose = True
auth_strategy = keystone
state_path = /var/lib/cinder
lock_path = /var/lock/cinder
volumes_dir = /var/lib/cinder/volumes
rabbit_host = 10.80.80.10
rabbit_password = C1oud-open
[database]
connection = mysql：//cinderuser：OPenstack@10.80.80.10/cinder

重启服务，命令如下：

# service cinder-volume restart

全部完成之后，可以在控制节点上运行命令cinder-manage service list，查看cindervolume服务是否正常运行。

2.2 在Ubuntu上使用源代码编译安装

对于各个版本的Linux来说，都会制作OpenStack相应的软件包。虽然在2.1节中介绍了二进制包安装，但是在这里笔者还是会讲一下源代码安装OpenStack基本组件的过程，因为从学习的角度来说，通过源代码安装OpenStack各个组件的过程，可以使读者对OpenStack的框架和各个组件的作用有一个比使用二进制安装更全面的了解。另一个好处是，二进制包的发布会滞后于源代码，如果想在第一时间尝试一些最新的功能或修复Bug后的版本，源代码安装是个不错的选择。当然，源代码安装比二进制包安装复杂，有一定的难度，并且要用户自己去解决一些依赖问题。

在本节中，将会介绍如何使用源代码方式安装Keystone、Glance、Nova、Neutron、Cinder和Horizon组件。OpenStack各个项目的代码都可以在GitHub（https：//github.com/ openstack）上获取。在接下来的安装过程中，笔者按照1个controller节点、1个network节点、1个compute节点、1个volume节点的架构来部署。因为其架构方式和二进制安装一样，所以一些基础配置，如每个节点的IP设置、NTP配置等，在本节中跳过。本节使用的操作系统依旧是Ubuntu 12.04 LTS版本。

2.2.1 控制节点的安装

在controller节点上计划部署如下组件：

· RabbitMQ

· PostgreSQL

· Keystone

· Glance

· Neutron

· Nova中除去nova-compute的其他组件

· Horizon

controller上各个组件负责的功能与使用二进制包安装时的一样。在本节中，如果没有特殊说明，那么与2.1节中介绍的架构一样，只是安装方式上有些区别。

1.前置准备

首先进行IP配置，以及RabbitMQ、NTP的安装配置，可参考2.1节相关内容。

使用PostgreSQL作为OpenStack的后端数据库。如果需要一个稳定的开源数据库，那么PostgreSQL可以优先考虑。此外，需要安装Python访问PostgreSQL时用的psycopg2，这是目前流行的PostgreSQL的Python连接库。命令如下：

# apt-get install postgresql postgresql-client
# apt-get install python-sqlalchemy python-psycopg2

创建一个数据库用户openstackdbadmin，设置密码为openstack123。这个用户将作为各个组件连接数据库的唯一用户。示例代码如下：

# su - postgres
$ psql
postgres=# CREATE USER openstackdbadmin with password
    'openstack123';
postgres=# \q

在二进制包安装的时候使用root用户，并且安装的时候会把配置文件配置成特定的用户组属性，不需要手动干预。但是在使用源代码安装的时候，必须处理好这些文件的用户组属性关系。在本节中，笔者将会以openstack这个用户的身份去安装、配置、启动服务。首先建立一个称为openstack的用户，并且加入到sudo组，让其有使用sudo的权限。命令如下：

# useradd -m openstack
# usermod -G sudo openstack

接下来的包都会放在openstack这个用户的主目录下，在这里是/home/openstack

提示

除非特殊说明，否则本节其余操作都是在openstack这个用户下执行。

下载需要用到的Git工具的源代码，在Ubuntu下安装，命令如下：

$ sudo apt-get install git

对于学习源代码安装的一个较好的，也是官方的方法就是阅读OpenStack开发人员写的一套安装脚本，我们称之为DevStack，其源代码在GitHub上维护（https：//github.com/openstack-dev/devstack）。这个项目的初衷是让开发人员能够快速建立一个完整的OpenStack开发环境，该项目由Rackspace的团队创建，并且由OpenStack的开发社区维护，它的脚本更新速度应该是最接近于OpenStack开发的，一些新的功能在脚本中都会更新体现出来。无论是开发人员还是系统运维工程师，这个脚本都是学习OpenStack的一个重要资源。后面的安装也是基于这个脚本的，会用到里面的一些文件，因此，首先需要下载该项目脚本的代码：

$ git clone https：//github.com/openstack-dev/devstack

源代码安装和二进制包安装的区别主要体现在几个方面，如果读者能把握住哪些是不同的，哪些是相同的，那么学会二进制包安装后，源代码安装的学习就会相对容易点。第一个区别是安装的软件包不同。在二进制包中，各个Linux发行平台已经把OpenStack组件中每个软件打成相应的包，其中包括运行组件所需的很多依赖包。而源代码安装方式，除了安装OpenStack社区发布的组件包外，还需要手动安装那些组件所需要的依赖包。能否完全正确地安装好依赖包是要解决的一个关键问题。第二个区别体现在配置文件上。二进制包安装好后，都会在/etc下建立好所需的配置文件。而源代码安装需要自己去建立相关目录。第三个区别是启动问题。在二进制包安装好后，往往都配置成了相应Linux系统版本的启动方式，譬如使用service启动。而源代码安装方式，需要自己写启动脚本，每个人的启动脚本和方式都不一样，因人而异。还有一些小的区别就是源代码安装需要建立用户，自己设置OpenStack组件的安装路径、用户、权限，手动建立一些必要的目录等。至于两者相同的地方，很明显就是数据库，以及配置文件中的参数。

OpenStack各个组件的配置文件都会放在/etc下的各个目录中，包括nova、glance、keystone、neutron等。这样做是为了统一规范每个组件的配置目录，方便管理。这里介绍一下安装的思路。一般情况下，在/etc下建立组件的目录，设置为用户的权限，在各个组件的源代码中也有相应的etc目录，其中包括需要用到的配置文件。把要用的配置文件从源代码目录复制到/etc下组件的目录中，然后编辑/etc下相应的配置文件。安装的思路是首先确保每个组件需要的依赖包已经安装，然后在源代码的第一层目录，执行Python的安装命令。这样一个组件就安装好了。

2.安装部署Keystone

首先下载Keystone源代码，并且切换到Havana版本的稳定分支：

$ git clone https：//github.com/openstack/keystone
$ cd keystone
$ git checkout stable/havana

在/etc下建立名为keystone的目录。设置属主为用户openstack。从下载的Keystone源代码中把/etc下的配置文件复制到/etc/keystone下，其代码如下：

$ sudo mkdir /etc/keystone
$ sudo chown openstack：openstack /etc/keystone
$ cd ～/keystone/etc
$ cp -p keystone.conf.sample /etc/keystone/keystone.conf
$ cp -p policy.json /etc/keystone/

Keystone有许多配置选项，这也是OpenStack一个比较大的特点。OpenStack会尽量支持更多的，同时比较流行的一些开源软件来完成类似功能。由于不同的开源软件有自身的特点和功能，因此OpenStack可给用户比较多的选择余地，用户可根据自身的情况选择适合的方式。在Keystone中，选择存放认证数据（包括用户、密码等数据）的方式时，可以选择LDAP、数据库。在这里我们把用得比较多，同时也比较容易上手的MySQL数据库作为存放数据的方式。在认证方式上，Keystone可以使用原有的UUID的方式，也可以选择后来加入的PKI方式来增强安全性。在本节中，会介绍一些使用广泛的配置，其他更多内容可以从第5章获取。需要配置keystone.conf以下主要的选项：

[DEFAULT]
admin_token = openstack
bind_host = 0.0.0.0
public_port = 5000
admin_port = 35357
debug = True
verbose = True
log_file = keystone.log
log_dir = /var/log/keystone
[sql]
connection = postgres：//openstackdbadmin：openstack123@localhost/keystone
[identity]
driver = keystone.identity.backends.sql.Identity
[catalog]
driver = keystone.catalog.backends.sql.Catalog
[token]
driver = keystone.token.backends.kvs.Token
[signing]
token_format = PKI

初始化Keystone，首先要创建Keystone所用的数据库，以及一些配置文件中用到的目录，然后初始化Keystone用的PKI。

需要创建不存在的目录，用来存放Keystone日志，可在keystone.conf中定义，其代码如下：

$ sudo mkdir /var/log/keystone
$ sudo chown openstack：openstack /var/log/keystone

需要创建不存在的目录，用来存放Keystone使用PKI的相关文件，其代码如下：

$ sudo mkdir /var/cache/keystone
$ sudo chown openstack：openstack /var/cache/keystone

创建Keystone所用的数据库，代码如下：

$ sudo su - postgres
$ psql
postgres=# CREATE DATABASE keystone;
postgres=# GRANT ALL PRIVILEGES ON DATABASE keystone TO openstackdbadmin;
postgres=# \q

切记要退出postgres用户，返回到OpenStack用户环境中，其代码如下：

postgres$ exit

进入devstack项目的目录，因为要用到里面的一些文件。

$ cd ～/devstack/files/apts

在devstack项目中，开发人员告诉了我们需要安装哪些前置依赖的和需要使用的第三方的软件包，这里需要安装general和keystone，其代码如下：

$ for i in'cut -f1 -d" " general keystone'; do sudo apt-get install -y $i; done

Keystone需要用到passlib软件包，使用PKI时必须安装，其代码如下：

$ sudo pip install passlib

安装Keystone组件，其代码如下：

$ cd ～/keystone
$ sudo python setup.py develop

进入Keystone目录，其代码如下：

$ cd ～/keystone
$ bin/keystone-manage db_sync
$ bin/keystone-manage pki_setup

下面开始安装Keystone Client。Keystone Client是一个使用Keystone的命令行接口工具，和Dashboard一样，它能完成大部分的日常操作。熟悉和熟练使用命令行工具对维护OpenStack及其每一个组件是非常重要的，系统管理员90%的工作是通过Client命令行完成的，而不是通过Dashboard。

切记退回到OpenStack的home目录，所有组件的顶层都在用户home目录下，其代码如下：

$ cd
$ git clone https：//github.com/openstack/python-keystoneclient
$ cd python-keystoneclient

在安装的过程中，如果出现依赖包安装报错的情况，可根据出错的Python软件包的URL进行手动下载，并进行安装，然后返回安装Keystone Client，其代码如下：

$ sudo python setup.py develop

3.使用tmux启动Keystone

至此，已经安装好了Keystone服务和命令行下的Keystone Client。接下来要启动Keystone进程。我们是通过源代码方式来安装Keystone的，没有配置成Ubuntu服务管理程序，因此，不能像二进制包方式安装后那样，通过命令“service keystone start”来启动，而是需要直接运行Keystone的可执行文件，并加上一些配置文件的参数。

$ cd ～/keystone

可执行文件都放在bin目录下。--config-file参数指明了Keystone的配置文件路径。

$ bin/keystone-all --config-file /etc/keystone/keystone.conf

启动完成后，是不是发现什么输出也没有，Shell也不会返回提示符？而一旦关掉SSH窗口或按<Crtl>+<C>组合键后，Keystone进程就结束了。是不是应该把这个程序放在后台运行呢？这里要用到终端复用软件tmux。tmux是一个类似于screen的软件，采用BSD授权。Ubuntu 12.04下默认安装了这个优秀的软件，在这里仅简单地使用它来打开一个会话。退出前面创建的Keystone进程，不要怕，因为我们已经学会如何启动Keystone了。用<Ctrl>+<C>组合键中断刚才创建的Keystone进程，当然也可以再开启一个终端会话窗口，用命令kill结束Keystone进程。

在下面这行代码中，new-session打开一个新的会话，-s给这个会话命名为keystone，按回车键之后可以看到一个空白的新的会话。

$ tmux new-session -s keystone

执行启动Keystone的命令，代码如下：

$ bin/keystone-all --config-file /etc/keystone/keystone.conf

读者可能会发现，这里介绍的内容看上去和前面介绍的内容差不多。然后先按住<Ctrl>和<B>键不放，然后再按<D>键，退出刚才新建的会话。是不是又返回到我们新建会话之前的窗口了？现在使用命令“ps aux | grep keystone”，查看一下Keystone的进程是否还存在。不存在的话记得发邮件告诉笔者。现在回到tmux，在源代码安装时会多次使用tmux，使用下面的命令可列出将会用到的和tmux相关的命令。

$ tmux new-session -s name

列出当前存在的所有的tmux会话，代码如下：

$ tmux list-sessions

返回会话名为name的会话，代码如下：

$ tmux attach-session -t name

现在可以使用命令“tmux attach-session -t keystone”回到刚才创建的Keystone会话中。tmux还有很多参数和命令，可以使用命令“man tmux”查看。

接下来是关于使用Keystone的内容，包括创建用户等，都和二进制包安装方式一样，读者可以参考2.1节的相关内容。

4.安装部署Glance

安装Glance的思路和过程与安装Keystone类似，大致的过程可以分为下载源代码、安装依赖软件包、安装Glance和Glance Client、编辑Glance的配置文件等。

提示

将OpenStack的数据目录放在/data下，包括Glance的镜像和Nova的虚拟机等。读者需要自己建立这个目录，并且确保这个目录足够大能满足用户环境所需的大小。

在安装过程中，确保这个目录所在的文件系统的可用空间有50GB，涉及的命令如下：

$ cd
$ git clone https：//github.com/openstack/glance
$ cd glance
$ git checkout stable/havana

安装Glance组件所需要的依赖软件，命令如下：

$ cd ～/devstack/files/apts
$ for i in ` cut -f1 -d" " glance`; do sudo apt-get install -y $i; done

安装Glance组件，代码如下：

$ cd ～/glance
$ sudo python setup.py develop

创建用来存放Glance配置文件的目录，和Keystone一样，也是放在/etc下，其代码如下：

    $ sudo mkdir -p /etc/glance
    $ sudo chown openstack：openstack
    $ cd ～/glance
    $ cp etc/glance-registry.conf /etc/glance/
$ vi /etc/glance/glance-registry.conf
[DEFAULT]
verbose = True
debug = True
bind_host = 0.0.0.0
bind_port = 9191
log_file = /var/log/glance/registry.log
sql_connection = connection = postgres：//openstackdbadmin：openstack123@
    localhost/glance
[paste_deploy]
flavor = keystone
[keystone_authtoken]
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = glance
admin_password = openstack
signing_dir = /var/cache/glance/registy
$ cp etc/glance-api.conf /etc/glance/
$ vi /etc/glance/glance-api.conf
[DEFAULT]
verbose = True
debug = True
default_store = file
bind_host = 0.0.0.0
bind_port = 9292
log_file = /var/log/glance/api.log
filesystem_store_datadir = /data/glance/images/
image_cache_dir = /var/cache/glance/
sql_connection = connection = postgres：//openstackdbadmin：openstack123@localhost/glance
[paste_deploy]
flavor = keystone+cachemanagement
[keystone_authtoken]
auth_host = 127.0.0.1
auth_port = 35357
auth_protocol = http
admin_tenant_name = service
admin_user = glance
admin_password = openstack
signing_dir = /var/cache/glance/api

注意

以上给出的是配置文件中需要修改和注意的部分，其他没有列出的按照默认设置即可，不要删除其他在这里没有列出的配置项。以下给出的配置也是如此。

建立专门的Glance目录用来存放镜像文件和镜像缓存，代码如下：

    $ sudo mkdir /data/glance
    $ sudo chown -R openstack：openstack /data/glance
    $ mkdir -p /data/glance/images
    $ mkdir -p /data/glance/cache
    $ cp -p etc/glance-regisgry-paste.ini /etc/glance/
    $ cp -p etc/glance-api-paste.ini /etc/glance/
    $ cp -p etc/glance-cache.conf /data/glance/cache/
    $ vi /data/glance/cache/glance-cache.conf
[DEFAULT]
verbose = True
debug = True
filesystem_store_datadir = /data/glance/images/
image_cache_dir = /data/glance/cache/
auth_url = http：//127.0.0.1：5000/v2.0/
admin_tenant_name = service
admin_user = glance
admin_password = openstack
    $ cp -p etc/policy.json /etc/glance/

在PostgreSQL中建立数据库glance，代码如下：

$ sudo su - postgres
$ psql
postgres=# CREATE DATABASE glance;
postgres=# GRANT ALL PRIVILEGES ON DATABASE glance TO openstackdbadmin;
postgres=# \q
postgres$ exit

初始化数据库glance中的表结构，代码如下：

$ bin/glance-manage db_sync
$ sudo mkdir -p /var/cache/glance/api
$ sudo chown openstack：openstack /var/cache/glance/api
$ sudo mkdir -p /var/cache/glance/registry
$ sudo chown openstack：openstack /var/cache/glance/registry
$ sudo mkdir /var/log/glance
$ sudo chown openstack：openstack /var/log/glance

下面安装Glance Client，代码如下：

$ cd && git clone https：//github.com/openstack/python-glanceclient
$ cd python-glanceclient && sudo python setup.py develop

5.启动Glance

Glance服务包括glance-registry和glance-api，需要分别启动这两个服务进程。同启动Keystone一样，使用tmux来建立两个新会话，分别命名为glance-registry和glance-api。命令如下：

$ cd ～/glance
$ tmux -c "bin/glance-registry --config-file=/etc/glance/glance-registry.conf"
$ tmux -c "bin/glance-api --config-file=/etc/glance/glance-api.conf"

6.安装部署Nova

首先下载Nova源代码，并且切换到Havana版本的稳定分支：

$ cd
$ git clone https：//github.com/openstack/nova
$ cd nova
$ git checkout stable/havana

安装Nova组件所需要的依赖软件，代码如下：

$ cd ～/devstack/files/apts
$ for i in ` cut -f1 -d" " nova`; do sudo apt-get install -y $i; done

安装Nova组件，代码如下：

$ cd ～/nova
$ sudo python setup.py develop

安装Nova Client，代码如下：

$ cd && git clone https：//github.com/openstack/python-novaclient$ cd python-novaclient && sudo python setup.py develop

配置Nova，主要是建立一些必要的目录，把配置文件从源代码目录中复制到/etc下，设置用户的sudo权限等，其代码如下：

$ cd ～/nova
$ sudo mkdir /etc/nova
$ sudo chown openstack：openstack /etc/nova
$ cp etc/nova/policy.json /etc/nova/
$ cp etc/nova/api-paste.ini /etc/nova/
$ cp etc/nova/nova.conf.sample /etc/nova/nova.conf
$ mkdir -m 755 /etc/nova/rootwrap.d
$ cp etc/nova/rootwrap.d/*.filters /etc/nova/rootwrap.d
$ sudo chown -R root：root /etc/nova/rootwrap.d
$ sudo chmod 644 /etc/nova/rootwrap.d/*
$ cp etc/nova/rootwrap.conf /etc/nova
$ sed -e "s：^filters_path=.*$：filters_path=/etc/nova/rootwrap.d：" -i /etc/nova/
    rootwrap.conf
$ sudo chown root：root /etc/nova/rootwrap.conf
$ sudo chmod 0644 /etc/nova/rootwrap.conf
$ sudo vi /etc/sudoers.d/nova-rootwrap

把以下内容添加到nova-rootwrap文件中。

openstack ALL=(root) NOPASSWD： /usr/local/bin/nova-rootwrap /etc/nova/rootwrap.conf *
$ sudo chmod 0440 /etc/sudoers.d/nova-rootwrap
$ sudo mkdir -p /var/nova
$ sudo chown openstack：openstack /var/cache/nova
$ sudo mkdir -p /data/nova
$ sudo chown -R openstack：openstack /data/nova
$ mkdir /data/nova/keys
$ sudo mkdir /var/log/nova
$ sudo chown -R openstack：openstack /var/log/nova

下载noVNC，因为noVNC不是OpenStack项目的组件，所以需要去noVNC的项目网站下载。

$ cd && git clone https：//github.com/kanaka/noVNC.git

接下来就是编辑配置文件，可参照2.1节相关内容。注意，把nova.conf中的state_path参数改成现在的/data/nova，数据库改成使用PostgreSQL的格式。配置文件完成之后，使用命令nova-manage运行“db sync”同步一下。

7.启动Nova服务

启动Nova的服务同样使用tmux，可参照Glance和Keystone的使用方式。启动的服务与二进制包安装方式一样，代码如下：

$ cd ～/nova
$ tmux -c "bin/nova-api --config-file=/etc/nova/nova.conf"
$ tmux -c "bin/nova-conductor --config-file=/etc/nova/nova.conf"
$ tmux -c "bin/nova-cert --config-file=/etc/nova/nova.conf"
$ tmux -c "bin/nova-scheduler --config-file=/etc/nova/nova.conf"
$ tmux -c "bin/nova-novncproxy --config-file=/etc/nova/nova.conf --web ～/noVNC"
$ tmux -c "bin/nova-consoleauth --config-file=/etc/nova/nova.conf"

8.安装配置neutron-server

安装neutron-server的方式和前面介绍的Keystone、Nova、Glance类似，主要思路是：下载源代码、安装源代码、建立Neutron和Open vSwitch plugin的目录并且设置权限、复制源代码中的配置文件到相应的目录中、设置rootwrap配置文件。剩下的和前几节类似，即修改配置文件内容、建立数据库、启动服务，这部分内容不再赘述。其代码如下：

$ cd
$ git clone https：//github.com/openstack/neutron
$ cd devstack/files/apts
$ for i in ` cut -f1 -d" " neutron`; do sudo apt-get install -y $i; done
$ cd ～/neutron
$ git checkout stable/havana
$ sudo python setup.py develop
$ sudo mkdir/etc/neutron
$ sudo chown openstack：openstack /etc/neutron
$ cd && cp etc/neutron.conf /etc/neutron
$ mkdir -p /etc/neutron/plugins/openvswitch
$ cp etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini /etc/neutron/plugins/
    openvswitch/
$ sudo mkdir /var/lib/neutron
$ sudo chown openstack：openstack /var/lib/neutron
$ mkdir -p -m 755 /etc/neutron/rootwrap.d
$ cp -pr etc/neutron/rootwrap.d/* /etc/neutron/rootwrap.d/
$ sudo chown -R openstack：openstack /etc/neutron/rootwrap.d
$ sudo chmod 644 /etc/neutron/rootwrap.d/*
$ cp etc/rootwrap.conf /etc/neutron/
$ sudo chown root：root /etc/neutron/rootwrap.conf
$ sudo chmod 0644 /etc/neutron/rootwrap.conf
$ sudo vi /etc/sudoers.d/neutron-rootwrap

把下面第一行代码加入到neutron-rootwrap文件中，接着执行余下命令。

openstack ALL=(root) NOPASSWD： /usr/local/bin/neutron-rootwrap /etc/neutron/rootwrap.conf *
$ sudo chmod 0440 /etc/sudoers.d/neutron-rootwrap
$ sudo chown root：root /etc/sudoers.d/neutron-rootwrap
$ cp etc/api-paste.ini /etc/neutron/
$ cp etc/policy.json /etc/neutron/
$ sudo mkdir /var/cache/neutron
$ sudo chown openstack：openstack /var/cache/neutron
$ cd ～/neutron
$ tmux -c "bin/neutron-server --config-file /etc/neutron/neutron.conf --config
    file /etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini"

安装Neutron Client，命令如下：

$ cd
$ git clone https：//github.com/openstack/python-neutronclient
$ cd python-neutronclient
$ sudo python setup.py develop

9.安装部署Cinder

下面安装Cinder组件，代码如下。注意，由于同前面其他组件安装类似，因此不再进行具体说明。

$ cd
$ git clone https：//github.com/openstack/cinder
$ cd devstack/files/apts
$ for i in ` cut -f1 -d" " cinder`; do sudo apt-get install -y $i; done
$ cd ～/cinder
$ git checkout stable/havana
$ sudo python setup.py develop
$ sudo mkdir -p /etc/cinder
$ sudo chown openstack：openstack /etc/cinder/
$ cp etc/cinder/policy.json /etc/cinder
$ sudo mkdir -m 755 /etc/cinder/rootwrap.d
$ sudo cp etc/cinder/rootwrap.d/*filters /etc/cinder/rootwrap.d/
$ sudo chown -R root：root /etc/cinder/rootwrap.d
$ sudo chmod 644 /etc/cinder/rootwrap.d/*
$ cp etc/cinder/rootwrap.conf /etc/cinder/
$ sudo chown root：root /etc/cinder/rootwrap.conf
$ sudo chmod 0644 /etc/cinder/rootwrap.conf
$ sudo vi /etc/sudoers.d/cinder-rootwrap

添加下面第一行代码到cinder-rootwrap文件中，接着执行余下命令。

openstack ALL=(root) NOPASSWD： /usr/local/bin/cinder-rootwrap /etc/cinder/
    rootwrap.conf *
$ sudo chmod 0440 /etc/sudoers.d/cinder-rootwrap
$ sudo chown root：root /etc/sudoers.d/cinder-rootwrap
$ cp etc/cinder/api-paste.ini /etc/cinder

其余的配置文件内容，包括安装tgt、建立数据库等内容，可参照2.1节相关内容。在控制节点上，启动cinder-api和cinder-scheduler服务即可，其代码如下：

$ tmux -c "bin/cinder-api --config-file=/etc/cinder/cinder.conf"
$ tmux -c "bin/cinder-scheduler --config-file=/etc/cinder/cinder.conf"

10.安装Horizon

安装Horizon的方法完全可以参照devstack的脚本，主要是先安装apache2等依赖软件包，然后复制配置文件，进行一定的修改即可，其代码如下：

$ cd
$ git clone https：//github.com/openstack/horizon
$ cd devstack/files/apts
$ for i in ` cut -f1 -d" " horizon`; do sudo apt-get install -y $i; done
$ cd ～/horizon
$ git checkout stable/havana
$ sudo python setup.py develop
$ cp openstack_dashboard/local/local_settings.py.example openstack_dashboard/
    local/local_settings.py
$ sudo mkdir -p ～/horzion/.blackhole
$ sudo rm -f /etc/apache2/sites-enabled/000-default
$ sudo touch /etc/apache2/sites-available/horizon.conf
$ sudo a2ensite horizon
$ cd ～/devstack
$ sudo sed -e "s,%USER%,openstack,g; s,%GROUP%,openstack,g;s,%HORIZO
    N_DIR%,/home/openstack/horizon,g;s,%APACHE_NAME%,apache2,g;s,%DEST%,
    /home/openstack,g;s,%HORIZON_REQUIRE%,,g;" files/apache-horizon.template >
    /etc/apache2/sites-available/horizon.conf

最后，重启Apache服务。

2.2.2 计算节点的安装

计算节点的任务就是负责运行虚拟机，对于计算节点操作系统的安装，默认把/目录分区尽量分配充足，至少50GB。这里使用KVM。此外，这个架构中使用的网络方式是Neutron，使用的Neutron的plugin是Open vSwitch，因此，还需要安装Neutron的Open vSwitch的agent，以及Open vSwitch本身。

需要使用或安装的组件：

· KVM、libvirt

· nova-compute

· neutron-plugin-openvswitch-agent

· Open vSwitch

注意

为了保证和controller节点的时间一致，需安装NTP并同步时间。

1.安装nova-compute

首先，回到工作目录，命令如下：

$ cd

下载devstack脚本和Nova的源代码，命令如下：

$ git clone https：//github.com/openstack-dev/devstack
$ git clone https：//github.com/openstack/nova

安装nova-compute所需要的依赖软件包，代码如下：

$ cd devstack/files/apts
$ for i in ` cut -f1 -d" " n-cpu`; do sudo apt-get install -y $i; done

安装nova-compute组件，代码如下：

$ cd ～/nova
$ git checkout stable/havana
$ sudo python setup.py develop

因为底层使用KVM虚拟化技术，所以必须安装KVM和libvirt库，命令如下：

$ sudo apt-get install -y kvm libvirt-bin python-libvirt

2.配置Nova相关文件

配置示例如下：

$ cd ～/nova
$ sudo mkdir /etc/nova
$ sudo chown openstack：openstack /etc/nova
$ cp etc/nova/api-paste.ini /etc/nova/
$ cp etc/nova/nova.conf.sample /etc/nova/nova.conf
$ mkdir -m 755 /etc/nova/rootwrap.d
$ cp etc/nova/rootwrap.d/*.filters /etc/nova/rootwrap.d
$ sudo chown -R root：root /etc/nova/rootwrap.d
$ sudo chmod 644 /etc/nova/rootwrap.d/*
$ cp etc/nova/rootwrap.conf /etc/nova
$ sed -e "s：^filters_path=.*$：filters_path=/etc/nova/rootwrap.d：" -i /etc/nova/
    rootwrap.conf
$ sudo chown root：root /etc/nova/rootwrap.conf
$ sudo chmod 0644 /etc/nova/rootwrap.conf
$ sudo vi /etc/sudoers.d/nova-rootwrap

把第一行内容添加到nova-rootwrap文件中，并执行余下命令。

openstack ALL=(root) NOPASSWD： /usr/local/bin/nova-rootwrap /etc/nova/rootwrap.conf *
     $ sudo chmod 0440 /etc/sudoers.d/nova-rootwrap

需要手动建立存放虚拟机文件的实际目录instances，代码如下：

$ sudo mkdir -p /data/nova/instances
$ sudo chown -R opsntack：openstack /data/nova
$ sudo mkdir /var/log/nova
$ sudo chown -R openstack：openstack /var/log/nova

3.配置nova-compute

配置示例如下：

$ sudo modprobe nbd || true/
$ sudo modprobe kvm || true/
$ kvm-ok
$ sudo vi /etc/libvirt/qemu.conf

修改qemu.conf文件中以下部分内容：

cgroup_device_acl = [
"/dev/null", "/dev/full", "/dev/zero",
"/dev/random", "/dev/urandom",
"/dev/ptmx", "/dev/kvm", "/dev/kqemu",
"/dev/rtc", "/dev/hpet","/dev/net/tun",
]
$ sudo usermod -G libvirtd openstack

然后修改配置文件，可参照2.1节相关内容，其代码如下。注意，在这个例子中，nova.conf中的state_path的目录应该设置成/data/nova。在一切配置完成之后，启动nova-compute服务。

$ cd ～/nova
$ tmux -c "sg libvirtd bin/nova-compute --config-file=/etc/nova/nova.conf"

4.安装Neutron的Open vSwitch plugin

计算节点需要使用Open vSwitch和Neutron的Open vSwitch plugin。在二进制包安装过程中，Open vSwitch在安装Neutron时候被依赖安装了，而在这里我们必须手动安装Open vSwitch，其代码如下：

$ sudo apt-get install -y openvswitch-switch openvswitch-datapath-dkms

Neutron的Open vSwitch plugin的源代码包含在Neutron中，参照控制节点安装neutronserver部分，建立相应的目录，把Open vSwitch的 plugin复制出来，然后编辑配置文件即可。完成后，运行neutron-openvswitch-plugin的命令如下：

$ cd ～/neutron
$ tmux -c "python neutron-openvswitch-agent --config-file /etc/neutron/neutron.
    conf --config-file /etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini"

2.2.3 网络节点的安装

网络节点需要安装Neutron和openvswitch-plugins。和计算节点一样，也需要手动安装Open vSwtich的包。在网络节点中，安装Neutron和openvswitch-plugins的方式和控制节点、计算节点的安装类似，唯一的区别是需要把源代码中关于dhcp-agent、l3-agent和metadataagent的配置文件复制到/etc/neutron目录中，其余的这里不再重复写出。这里给出启动三个服务的命令：

$ tmux -c "python neutron-dhcp-agent --config-file /etc/neutron/neutron.conf --
    config-file /etc/neutron/dhcp_agent.ini"
$ tmux -c "python neutron-l3-agent --config-file /etc/neutron/neutron.conf --
    config-file /etc/neutron/l3_plugin.ini"
$ tmux -c "python neutron-metadata-agent --config-file /etc/neutron/neutron.conf --
    config-file /etc/neutron/metadata_plugin.ini"

网络节点需要新建相关目录，代码如下：

$ sudo mkdir /var/lib/neutron
$ sudo chown openstack：openstack /var/lib/neutron

2.2.4 块存储节点的安装

块存储节点运行cinder-volume服务，这个服务同样包含在Cinder的安装中，可参照在控制节点中安装Cinder服务的那一部分。启动cinder-volume的命令如下：

$ tmux -c "bin/cinder-volume --config-file=/etc/cinder/cinder.conf"

最后，从自身的学习经验来看，笔者建议读者先从二进制包安装方式开始，因为Linux发行版本厂商已经帮用户解决了很多依赖包的关联，并且建立好了相关的目录和目录下需要用的配置文件，用户和目录权限无须配置。用户或者管理员可以专注于各个组件的配置参数，以便建立起一个正常运行的OpenStack云环境。学习二进制包安装后，读者可以循序阅读后面如何使用OpenStack的章节，对OpenStack整个框架使用有个大致的了解之后再来学习源代码安装。笔者在这里给出的源代码安装步骤相对简单，而且由于随着版本的更新，可能会不适用于新的版本中。推荐读者对这里介绍的安装过程熟悉之后，去阅读官方的devstack的脚本，它是一个一直在保持更新的脚本，添加了更多功能的支持，譬如Nova的cell服务、Neutron的其他plugin、Ceilometer、Heat等新的项目组件；同时，该脚本也支持在CentOS 6.5上进行源代码安装。

上一章目录下一章