1
00:00:00,000 --> 00:00:10,811

2
00:00:10,811 --> 00:00:12,060
LEO ZHADANOVSKY：嗨，大家好。

3
00:00:12,060 --> 00:00:13,675
我是狮子座Zhadanovsky。

4
00:00:13,675 --> 00:00:17,000
我是一个解决方案架构师
亚马逊Web服务。

5
00:00:17,000 --> 00:00:21,030
而我今天要和你谈谈
什么亚马逊Web Services是，

6
00:00:21,030 --> 00:00:25,170
它的历史，简要概述
我们所提供的服务。

7
00:00:25,170 --> 00:00:29,530
而且我会做的现场演示
如何推出AWS一个LAMP堆栈

8
00:00:29,530 --> 00:00:33,769
无论在单个实例和
通过使用我们的一些其他的

9
00:00:33,769 --> 00:00:36,060
[？管理？]服务，例如
作为我们的关系型数据库

10
00:00:36,060 --> 00:00:39,330
服务，我们的负载
平衡器，和我们的实例。

11
00:00:39,330 --> 00:00:41,610
>> 因此，首先，让我们
谈到AWS的历史。

12
00:00:41,610 --> 00:00:47,780
因此，如何做Amazon.com进入
这种云计算的公司吗？

13
00:00:47,780 --> 00:00:51,630
那么，亚马逊在真正的好
提供一个大的产品选择

14
00:00:51,630 --> 00:00:54,440
和运输那些
客户有效。

15
00:00:54,440 --> 00:00:57,870
后面这种能力
在于多年的经验

16
00:00:57,870 --> 00:01:01,330
与操作的数据中心，与
物流，有各种各样的东西。

17
00:01:01,330 --> 00:01:05,420
因此，我们发现
超过10年，我们

18
00:01:05,420 --> 00:01:10,840
想使我们的客户
做了很多不同的东西，对不对？

19
00:01:10,840 --> 00:01:16,870
>> 因此，我们最后提供一些内部
服务达第三方卖家。

20
00:01:16,870 --> 00:01:20,640
当我们发表简单的Web服务
比如我们的目录检索。

21
00:01:20,640 --> 00:01:22,910
并成为真正的
显而易见的真快

22
00:01:22,910 --> 00:01:26,530
开发商都饿了
更多的我们的服务。

23
00:01:26,530 --> 00:01:29,830
所以这促使我们开发AWS。

24
00:01:29,830 --> 00:01:31,910
因此，我们问我们什么
可以打包一切

25
00:01:31,910 --> 00:01:36,620
我们这样做，并提供给
其他人在网上？

26
00:01:36,620 --> 00:01:41,940
>> 因此，AWS的使命是使
企业和开发人员

27
00:01:41,940 --> 00:01:46,080
使用Web服务来构建
可扩展的复杂的应用程序。

28
00:01:46,080 --> 00:01:49,650
和web服务是什么
现在人们称之为云计算。

29
00:01:49,650 --> 00:01:53,180
于是在2006年，AWS诞生了。

30
00:01:53,180 --> 00:01:56,590
让我们来谈谈
什么AWS实际上是。

31
00:01:56,590 --> 00:02:01,310
>> 因此，我们提供不同的
在不同层次的服务。

32
00:02:01,310 --> 00:02:06,060
因此，我们有一种我们的核心业务，
我们计算的存储和数据库。

33
00:02:06,060 --> 00:02:08,250
然后我们也有
一个网络层，

34
00:02:08,250 --> 00:02:10,289
我们已经有了一个全球性
基础设施，因此我们

35
00:02:10,289 --> 00:02:13,812
在世界各地得到了地区和
世界各地的供应区域。

36
00:02:13,812 --> 00:02:15,520
然后我们有
较高层次的服务，

37
00:02:15,520 --> 00:02:18,670
如应用服务
用于构建水平

38
00:02:18,670 --> 00:02:20,434
可扩展的应用程序。

39
00:02:20,434 --> 00:02:22,850
然后，我们已经有了部署
和管理服务。

40
00:02:22,850 --> 00:02:26,010
因此，这些都是服务，你
用来部署你的代码在AWS

41
00:02:26,010 --> 00:02:29,100
并管理您的
AWS帐号，因为它扩展。

42
00:02:29,100 --> 00:02:32,120
>> 因此，让我们来谈谈我们
第一个全球性的基础设施。

43
00:02:32,120 --> 00:02:35,960
我们有世界各地的11个地区。

44
00:02:35,960 --> 00:02:39,680
所以，我们只是增加了一个新的区域
几个星期前在法兰克福，

45
00:02:39,680 --> 00:02:41,500
但每个区域是
就像一个单独的云。

46
00:02:41,500 --> 00:02:43,580
因此，这些服务我
要谈，就

47
00:02:43,580 --> 00:02:46,350
存在于不同的区域。

48
00:02:46,350 --> 00:02:50,370
所以在美国，有一个
区域在弗吉尼亚州北部。

49
00:02:50,370 --> 00:02:54,390
有一个区域在北
加利福尼亚州和俄勒冈州。

50
00:02:54,390 --> 00:02:57,690
>> 在俄勒冈州的区域
也是碳中性。

51
00:02:57,690 --> 00:03:00,200
我们也有一个区域
俄勒冈称为GovCloud。

52
00:03:00,200 --> 00:03:05,370
所以，如果你有一个工作量需要
要符合ITAR，所以这是

53
00:03:05,370 --> 00:03:09,580
国际交通和武器削减
条约，你应该使用GovCloud。

54
00:03:09,580 --> 00:03:12,510
>> 所以，最重要的事情
关于这是你

55
00:03:12,510 --> 00:03:15,100
挑选在您的数据
去哪里你的应用程序去。

56
00:03:15,100 --> 00:03:19,370
所以我们不跨越移动数据
地区或跨区域的可用性

57
00:03:19,370 --> 00:03:22,277
如果它是一个服务，您可以
选择可用性区域。

58
00:03:22,277 --> 00:03:23,860
你可以挑选，哪里就有奇迹。

59
00:03:23,860 --> 00:03:24,526
您可以移动它。

60
00:03:24,526 --> 00:03:27,920
我们为您提供的工具来移动你
数据，但我们不会将它给你。

61
00:03:27,920 --> 00:03:30,710
>> 因此每个区域内有
至少有两个可用区域，

62
00:03:30,710 --> 00:03:33,020
我们将谈论什么
那些是在一秒钟。

63
00:03:33,020 --> 00:03:35,530
还有还有52边缘
在世界各地。

64
00:03:35,530 --> 00:03:40,850
所以边沿位置基本上我们
CloudFront的，[？云？]分布

65
00:03:40,850 --> 00:03:43,410
网络，我们的路线53 DNS服务。

66
00:03:43,410 --> 00:03:47,100
所以有很多人
因为它们是更接近用户，

67
00:03:47,100 --> 00:03:49,360
因为这些都是
潜伏期为基础的服务。

68
00:03:49,360 --> 00:03:51,410
所以延迟事项它们。

69
00:03:51,410 --> 00:03:54,630
>> 因此，这是一个典型的
区域模样。

70
00:03:54,630 --> 00:03:56,630
进而[？内？]
每个区域有，

71
00:03:56,630 --> 00:03:58,530
就像我说的，至少
2可用区。

72
00:03:58,530 --> 00:04:01,390
可用性区
至少一个数据中心，

73
00:04:01,390 --> 00:04:04,340
有时也可以是内更
相同的地理区域。

74
00:04:04,340 --> 00:04:09,010
而我们的可用性区设计
要在不同的河漫滩，故障

75
00:04:09,010 --> 00:04:15,501
平原有明显的权力
公用事业和不同的一级互联网服务供应商。

76
00:04:15,501 --> 00:04:17,500
所以，你应该设计你的
应用[？介意吗？]

77
00:04:17,500 --> 00:04:20,240
那里的东西都可能发生
在一个可用性区域，

78
00:04:20,240 --> 00:04:23,245
但所以你应该摊开你的
在多个应用程序的可用性

79
00:04:23,245 --> 00:04:27,100
区，因为他们正在建
这些裁员的初衷。

80
00:04:27,100 --> 00:04:30,490
>> 因此，我们的电源很多
你认识的企业。

81
00:04:30,490 --> 00:04:36,590
所以从Airbnb住宿，Netflix的，
到Dropbox的，以Yelp的，

82
00:04:36,590 --> 00:04:41,270
我们有各种创业公司和
对我们的工作负载运行的企业。

83
00:04:41,270 --> 00:04:44,610
在公共部门，我们有
各类政府机构

84
00:04:44,610 --> 00:04:47,740
对我们来说，edtech
初创企业，大学。

85
00:04:47,740 --> 00:04:52,910
奥巴马竞选基本上都跑了
他们在Amazon Web Services的东西。

86
00:04:52,910 --> 00:04:56,690
>> 而刚刚给你透视
我们的缩放，平均每天

87
00:04:56,690 --> 00:05:00,840
我们有足够的新服务器
容量支持

88
00:05:00,840 --> 00:05:04,400
Amazon.com的全球基础设施
当它是一个十亿$ 7

89
00:05:04,400 --> 00:05:05,740
企业早在2004年。

90
00:05:05,740 --> 00:05:08,500
所以这就是多少，我们
对平均一天。

91
00:05:08,500 --> 00:05:11,910
>> 所以一般的概念是，如果你
想想你如何获得权力。

92
00:05:11,910 --> 00:05:14,940
所以，你得到的功率，它的需求，对不对？

93
00:05:14,940 --> 00:05:19,580
所以你知道，当你得到
它，你知道你可以得到它。

94
00:05:19,580 --> 00:05:22,950
它是统一的，所以你知道
什么电压你得到。

95
00:05:22,950 --> 00:05:26,940
它是现收现付，这样你付出
你到底有多少使用。

96
00:05:26,940 --> 00:05:29,020
和它的使用。

97
00:05:29,020 --> 00:05:31,060
所以你插上，你知道
你会得到力量。

98
00:05:31,060 --> 00:05:34,350
所以，我们已经采取了和
它扩展到计算机。

99
00:05:34,350 --> 00:05:36,710
>> 因此，这解决了很多问题。

100
00:05:36,710 --> 00:05:41,230
我们通常看到很多
IT组织。

101
00:05:41,230 --> 00:05:43,130
他们有这个能力的问题。

102
00:05:43,130 --> 00:05:46,370
因此，他们有一定的金额
IT需求，然后他们

103
00:05:46,370 --> 00:05:49,290
有过度供应的能力。

104
00:05:49,290 --> 00:05:53,110
因此，无论他们的方式过度配置，
或者它们不具有足够的容量，

105
00:05:53,110 --> 00:05:54,930
他们有不满意的客户。

106
00:05:54,930 --> 00:05:59,820
>> 因此，例如，这些都是
不同的交通模式。

107
00:05:59,820 --> 00:06:01,980
因此，无论你有东西
该打开和关闭，

108
00:06:01,980 --> 00:06:05,920
或生长快，或具有可变峰
或可预测的峰值，对于所有这些，

109
00:06:05,920 --> 00:06:08,122
你要么去
过规定通常情况下，

110
00:06:08,122 --> 00:06:09,580
或者你要下的规定。

111
00:06:09,580 --> 00:06:12,990
所以，你要么浪费，或
你有不满意的客户。

112
00:06:12,990 --> 00:06:17,400
>> 那么，什么AWS允许你做的是你
可以动态地扩展上下

113
00:06:17,400 --> 00:06:19,510
根据你的
实际的使用模式是。

114
00:06:19,510 --> 00:06:23,270
所以，你可以为你使用的服务付费。

115
00:06:23,270 --> 00:06:25,115
你可以启动
实例，所以实例

116
00:06:25,115 --> 00:06:27,030
是我们对虚拟服务器的话。

117
00:06:27,030 --> 00:06:29,280
您可以启动1
例如，你可以启动

118
00:06:29,280 --> 00:06:33,160
数千实例在几分钟或
秒，丝毫不亚于你所需要的。

119
00:06:33,160 --> 00:06:35,897
你可以拨打起来
上下按要求。

120
00:06:35,897 --> 00:06:38,730
因此，让我和你谈的
例如这是一种离家近。

121
00:06:38,730 --> 00:06:44,930
所以这是一个典型的交通
图表十一月Amazon.com。

122
00:06:44,930 --> 00:06:49,491
而最后两个峰这里，
没有人知道它们是什么？

123
00:06:49,491 --> 00:06:49,990
所以they're--

124
00:06:49,990 --> 00:06:51,180
>> 听众：网络星期一？

125
00:06:51,180 --> 00:06:53,430
>> LEO ZHADANOVSKY：网络星期一
和黑色星期五，对不对？

126
00:06:53,430 --> 00:06:57,020
所以传统，什么Amazon.com有
做的是，他们不得不提供能力

127
00:06:57,020 --> 00:06:58,330
涵盖这两个高峰。

128
00:06:58,330 --> 00:07:04,490
因此，作为其结果，时间76％，
他们有太多的能力。

129
00:07:04,490 --> 00:07:07,640
而只有24％的时间
被他们充分利用它。

130
00:07:07,640 --> 00:07:12,730
所以在2010年Amazon.com转身
关闭其最后一个物理Web服务器

131
00:07:12,730 --> 00:07:14,430
并把它移植到AWS。

132
00:07:14,430 --> 00:07:16,660
原来这就是交通
模式貌似现在。

133
00:07:16,660 --> 00:07:19,240
容量略高于
什么实际需要。

134
00:07:19,240 --> 00:07:23,100
>> 那么，为什么我们看到客户采用
云计算AWS这么快？

135
00:07:23,100 --> 00:07:24,480
那么，敏捷性。

136
00:07:24,480 --> 00:07:27,090
所以这是主要的
原因是我们看到的。

137
00:07:27,090 --> 00:07:28,590
为什么敏捷很重要？

138
00:07:28,590 --> 00:07:31,790
那么，它允许客户
做的事情，在旧世界

139
00:07:31,790 --> 00:07:36,090
花了几个星期或几个月做
它们在几分钟或几秒钟。

140
00:07:36,090 --> 00:07:39,510
所以，你可以做的事情一样旋转了
全新的开发和测试环境，

141
00:07:39,510 --> 00:07:42,010
旋转了一个全新的DR
环境，旋转起来

142
00:07:42,010 --> 00:07:45,180
50个实例，或1000
针对高峰流量情况下，

143
00:07:45,180 --> 00:07:49,140
除去那些1000实例，设置
了一个HPC集群，或GS集群，

144
00:07:49,140 --> 00:07:51,430
你可以这样做
所有在AWS分钟。

145
00:07:51,430 --> 00:07:54,960
>> 所以，这是什么导致的
创新文化。

146
00:07:54,960 --> 00:07:57,290
所以，你可以经常体验。

147
00:07:57,290 --> 00:08:00,190
你可以只为您所使用的支付
你可以没有风险的失败。

148
00:08:00,190 --> 00:08:04,477
所以，如果你尝试的东西出来，你
付出了几个小时的使用。

149
00:08:04,477 --> 00:08:05,310
这不是什么大不了的事。

150
00:08:05,310 --> 00:08:08,150
你有没有把一个大的资本
投资前面的那个。

151
00:08:08,150 --> 00:08:10,930
>> 那么，什么是客户
实际使用AWS的？

152
00:08:10,930 --> 00:08:16,170
好吧，让圣母大学，
他们搬到他们的网站转移到AWS。

153
00:08:16,170 --> 00:08:21,150
他们有一个平均约38000
每天的游客到他们的网站，

154
00:08:21,150 --> 00:08:26,150
但它可以在膨胀到150000
体育赛事和足球比赛。

155
00:08:26,150 --> 00:08:29,840
于是，他们把他们的网站上给我们。

156
00:08:29,840 --> 00:08:33,650
而现在他们的网站能够支持
流量增长了500％，所有的

157
00:08:33,650 --> 00:08:36,600
虽然他们已经保存
在现有的40％

158
00:08:36,600 --> 00:08:39,120
内部部署设置为自己的网站。

159
00:08:39,120 --> 00:08:47,530
>> 美国航空航天局喷气推进实验室，他们使用AWS的生活流
好奇心火星车着陆。

160
00:08:47,530 --> 00:08:51,320
等他们发现
只有六个提前天

161
00:08:51,320 --> 00:08:53,650
他们需要
另寻供应商

162
00:08:53,650 --> 00:08:56,030
从他们的常规供应商
他们的现场直播。

163
00:08:56,030 --> 00:08:58,140
这也同样
时间作为奥运会。

164
00:08:58,140 --> 00:09:01,686
这样他们就可以不买CDM
容量在时间的任何地方。

165
00:09:01,686 --> 00:09:04,310
所以他们基本建立
自己的内容分发网络

166
00:09:04,310 --> 00:09:07,240
我们在六天内EC2服务。

167
00:09:07,240 --> 00:09:10,090
并且他们能够有
它扩展到他们的需求。

168
00:09:10,090 --> 00:09:13,480
他们是，我认为，展望
约100万名观众。

169
00:09:13,480 --> 00:09:16,200
所以这是一个非常有趣的
技术进他们使用，

170
00:09:16,200 --> 00:09:18,990
Adobe Flash媒体服务器
和[？互联网？]缓存。

171
00:09:18,990 --> 00:09:23,350
而且他们能够部署全
这些集群编程为

172
00:09:23,350 --> 00:09:23,850
必要的。

173
00:09:23,850 --> 00:09:26,590
然后，他们纺下来时，
他们没有使用它们了。

174
00:09:26,590 --> 00:09:32,680
>> 奥巴马的竞选班子在2012年使用
AWS超过200个应用程序

175
00:09:32,680 --> 00:09:34,950
他们主办的平台上。

176
00:09:34,950 --> 00:09:39,010
他们拥有一切，从
打电话的工具，以支付处理，

177
00:09:39,010 --> 00:09:43,920
移动的应用程序，以
志愿者组织的网站，

178
00:09:43,920 --> 00:09:47,269
以大数据分析工具。

179
00:09:47,269 --> 00:09:49,060
和一切都得
在选举日的工作。

180
00:09:49,060 --> 00:09:52,459
所以移动选举日会
需要修改宪法，

181
00:09:52,459 --> 00:09:53,750
所以这是不会发生的。

182
00:09:53,750 --> 00:09:56,208
所以，所有的系统都将
有工作的第一天。

183
00:09:56,208 --> 00:09:57,670
而他们做到了。

184
00:09:57,670 --> 00:10:00,660
>> 因此，让我们来谈谈实际的服务。

185
00:10:00,660 --> 00:10:03,130
因此，首先在网络服务。

186
00:10:03,130 --> 00:10:06,750
所以亚马逊VPC是
虚拟私有云。

187
00:10:06,750 --> 00:10:09,500
它基本上是一个
软件定义的网络

188
00:10:09,500 --> 00:10:13,910
那住在你的EC2实例的基础上，
和你的RDS，我们将谈论，

189
00:10:13,910 --> 00:10:15,120
和ElastiCache。

190
00:10:15,120 --> 00:10:20,080
>> 所以你可以定义一个私人
为实例的地址空间。

191
00:10:20,080 --> 00:10:22,820
你可以打破成
公共子网，专用子网。

192
00:10:22,820 --> 00:10:27,790
你可以做VPN连接
内部部署的数据中心。

193
00:10:27,790 --> 00:10:33,635
那么你也可以延长您
内部部署的地址空间的VPC。

194
00:10:33,635 --> 00:10:37,400
你有权力操纵路线
表，以便您可以自定义的东西。

195
00:10:37,400 --> 00:10:40,450
您有网络
在VPC控制列表。

196
00:10:40,450 --> 00:10:42,370
[？所以它？]给你
一个很大的灵活性

197
00:10:42,370 --> 00:10:45,640
在你在AWS已经运行。

198
00:10:45,640 --> 00:10:47,140
>> 再有就是AWS的DirectConnect。

199
00:10:47,140 --> 00:10:50,820
所以的DirectConnect是一个私人
连接到我们的地区。

200
00:10:50,820 --> 00:10:54,380
所以，你可以得到一个或一个万兆
链接或多个一个或万兆链路

201
00:10:54,380 --> 00:10:55,720
最多的区域。

202
00:10:55,720 --> 00:10:58,470
所以，如果你上传了很多
数据或下载大量的数据

203
00:10:58,470 --> 00:11:01,440
而需要私人连接，
这是一个选项出现。

204
00:11:01,440 --> 00:11:02,710
>> 还有路线53。

205
00:11:02,710 --> 00:11:05,410
所以，53路是我们的DNS服务。

206
00:11:05,410 --> 00:11:07,860
它各种有趣的事情。

207
00:11:07,860 --> 00:11:09,250
因此，它支持健康检查。

208
00:11:09,250 --> 00:11:12,590
所以，你可以，比如说，运行两个副本
你的网站在同一时间。

209
00:11:12,590 --> 00:11:15,860
如果其中一个出现故障，你
将流量重定向到其他副本。

210
00:11:15,860 --> 00:11:20,400
>> 或者你可以做地理位置为基础的记录
这样你就可以将流量路由一个国家

211
00:11:20,400 --> 00:11:22,870
从另外一个簇
国家到另一个集群。

212
00:11:22,870 --> 00:11:27,140
你可以做A / B测试，所以你
能有80％的流量

213
00:11:27,140 --> 00:11:30,510
您的网站的一个副本，
20％到您的网站的新副本

214
00:11:30,510 --> 00:11:33,120
，看看哪一个性能更好。

215
00:11:33,120 --> 00:11:35,385
所以，你可以做各种
有趣的事情。

216
00:11:35,385 --> 00:11:36,760
你可以根据延迟的记录。

217
00:11:36,760 --> 00:11:39,160
所以，你可以有你的份
网站在世界各地

218
00:11:39,160 --> 00:11:43,500
并已在用户发送给任何
一个人的最亲密的人的基础上的延迟。

219
00:11:43,500 --> 00:11:46,030
它还具有深度整合
与AWS服务，

220
00:11:46,030 --> 00:11:50,980
因此，如我们的负载均衡器，
和S3，和CloudFront的，

221
00:11:50,980 --> 00:11:53,680
所以它真的很容易
点事情CloudFront的

222
00:11:53,680 --> 00:11:57,190
为您分布
的LB或S3桶。

223
00:11:57,190 --> 00:11:57,930
>> 然后还有EC2。

224
00:11:57,930 --> 00:12:00,432
所以EC2是我们的虚拟服务器服务。

225
00:12:00,432 --> 00:12:01,390
您可以在Windows上运行。

226
00:12:01,390 --> 00:12:02,560
您可以在其上运行的Linux。

227
00:12:02,560 --> 00:12:05,230
您可以完全控制
的操作系统。

228
00:12:05,230 --> 00:12:09,519
还有的Windows不同口味
和Linux，所以红帽，Debian的，Ubuntu的。

229
00:12:09,519 --> 00:12:11,560
我们有自己的配送
所谓亚马逊的Linux。

230
00:12:11,560 --> 00:12:14,000
你可以选择你想要哪一个。

231
00:12:14,000 --> 00:12:15,680
>> 有不同类型的实例。

232
00:12:15,680 --> 00:12:18,330
因此，有超过27的实例
类型在这一点上。

233
00:12:18,330 --> 00:12:21,590
因此，有不同的实例
根据不同的工作负载的家庭。

234
00:12:21,590 --> 00:12:23,550
因此，有普遍
目的情况下，这

235
00:12:23,550 --> 00:12:26,910
只是，如果你不知道什么
你需要，你可以用这些启动。

236
00:12:26,910 --> 00:12:30,620
>> 还有的计算优化，它们是
伟大的事情，如Web服务器，

237
00:12:30,620 --> 00:12:31,160
对不对？

238
00:12:31,160 --> 00:12:33,450
还有的内存优化
实例，

239
00:12:33,450 --> 00:12:36,190
是伟大的事情一样
日期的关系数据库。

240
00:12:36,190 --> 00:12:41,230
有存储优化实例，
所以这些对他们大固态硬盘。

241
00:12:41,230 --> 00:12:46,440
因此，他们是伟大的事情
像蒙戈或NoSQL的，对不对？

242
00:12:46,440 --> 00:12:49,750
>> 这里面的图形
优化的情况下，

243
00:12:49,750 --> 00:12:52,970
这是伟大的GPU
计算和集群实例。

244
00:12:52,970 --> 00:12:54,940
而且最后还有成本
优化的实例。

245
00:12:54,940 --> 00:12:56,850
所以，如果你只是想
实验，你

246
00:12:56,850 --> 00:13:01,820
可以得到一堆低成本实例
这是伟大的是用例类型。

247
00:13:01,820 --> 00:13:03,330
再有就是自动缩放。

248
00:13:03,330 --> 00:13:07,840
因此，自动缩放是EC2的API。

249
00:13:07,840 --> 00:13:12,360
它可以让你的规模水平
上下EC2实例的层次。

250
00:13:12,360 --> 00:13:14,460
因此，让我们说你有
一堆Web服务器。

251
00:13:14,460 --> 00:13:17,970
>> 而且，像在巴黎圣母院的情况下，你
通常你需要有两个人，

252
00:13:17,970 --> 00:13:19,519
但是你可能需要的规模为10。

253
00:13:19,519 --> 00:13:21,810
那么，你可以使用自动缩放
自动触发

254
00:13:21,810 --> 00:13:24,360
向上或向下扩展事件
基于度量。

255
00:13:24,360 --> 00:13:28,020
所以，[？ CPU？]使用率，潜伏期。

256
00:13:28,020 --> 00:13:30,570
你可以自定义的指标，所以
这是相当开放式的存在。

257
00:13:30,570 --> 00:13:32,490
>> 您也可以根据时间表规模。

258
00:13:32,490 --> 00:13:36,180
所以，如果你知道你将有
周一大量的流量在上午6:00，

259
00:13:36,180 --> 00:13:40,150
你可以在星期一扩大在上午6:00
并缩减在周一下午5:00。

260
00:13:40,150 --> 00:13:43,610
您也可以做到这一点的基础上
只是命令行命令。

261
00:13:43,610 --> 00:13:45,150
>> 再有就是弹性负载均衡。

262
00:13:45,150 --> 00:13:48,070
所以弹性负载均衡
是一个托管负载平衡器。

263
00:13:48,070 --> 00:13:51,590
所以，你点击一个按钮，它
规定负载平衡器你。

264
00:13:51,590 --> 00:13:54,610
负载平衡器住在
多个可用区。

265
00:13:54,610 --> 00:14:00,570
它SSL卸载
为端口25，80，443，

266
00:14:00,570 --> 00:14:05,750
和任何超过1024的TCP流量。

267
00:14:05,750 --> 00:14:09,469
>> 它连接排水，
代理协议支持。

268
00:14:09,469 --> 00:14:11,135
所以这是一个非常多特征负载平衡器。

269
00:14:11,135 --> 00:14:13,440
而且它有整合
与自动缩放。

270
00:14:13,440 --> 00:14:16,690
所以，当你使用自动缩放
而你缩放上下，

271
00:14:16,690 --> 00:14:19,700
你可以有你的情况下，
自动加入或离开

272
00:14:19,700 --> 00:14:21,810
弹性负载平衡器。

273
00:14:21,810 --> 00:14:23,980
>> 所以，再有就是我们的存储服务。

274
00:14:23,980 --> 00:14:27,170
所以，第一个是亚马逊
EBS，或弹性块存储。

275
00:14:27,170 --> 00:14:32,720
这是持久的卷
你可以安装到你的EC2实例。

276
00:14:32,720 --> 00:14:34,800
所以，你可以快照他们。

277
00:14:34,800 --> 00:14:39,550
所以当快照的EBS
量，它进入S3，

278
00:14:39,550 --> 00:14:41,730
我们将在第二讲。

279
00:14:41,730 --> 00:14:44,080
有三种不同
类型EBS卷。

280
00:14:44,080 --> 00:14:48,350
>> 有磁性EBS，这仅仅是
排序标准的排序磁盘的。

281
00:14:48,350 --> 00:14:51,030
这是最经济的选择。

282
00:14:51,030 --> 00:14:53,210
再有就是一般
SSD的目的，在这里我们

283
00:14:53,210 --> 00:14:55,830
让每GB提供3 IOPS。

284
00:14:55,830 --> 00:14:59,080
所以，如果你有一兆兆字节
音量，你有3000 IOPS。

285
00:14:59,080 --> 00:15:02,730
再有就是置备IOPS。

286
00:15:02,730 --> 00:15:06,660
所以，配置的IOPS是当你
为你付出多少磁盘空间使用

287
00:15:06,660 --> 00:15:08,270
多少IOPS能力需要。

288
00:15:08,270 --> 00:15:12,150
这样你就可以准备起来
每卷4000 IOPS。

289
00:15:12,150 --> 00:15:16,360
>> 所以，再有就是亚马逊S3。

290
00:15:16,360 --> 00:15:19,340
亚马逊S3是我们的对象存储。

291
00:15:19,340 --> 00:15:23,230
所以亚马逊S3，你可以用它
只存储任何类型的数据。

292
00:15:23,230 --> 00:15:27,850
你可以用它来存储静态
网站和软管静态网站。

293
00:15:27,850 --> 00:15:32,870
您可以使用S3进行备份
而且在某些情况下，使用档案

294
00:15:32,870 --> 00:15:40,500
作为源和输出桶
大数据分析，或转码。

295
00:15:40,500 --> 00:15:47,700
它也可以用来作为原点
为CloudFront的分布。

296
00:15:47,700 --> 00:15:49,180
>> 所以S3的超级强大。

297
00:15:49,180 --> 00:15:52,660
S3的设计为11
线的耐用性。

298
00:15:52,660 --> 00:15:55,480
所以，这是什么意思是它能够持续
至少两个数据的丢失

299
00:15:55,480 --> 00:16:00,790
中心在同一时间
而不会丢失数据。

300
00:16:00,790 --> 00:16:02,050
你可以在S3加密。

301
00:16:02,050 --> 00:16:05,150
因此，服务器设置加密，或服务器
设置加密功能，与你的密钥。

302
00:16:05,150 --> 00:16:08,870
所以，如果你要管理的
键，你可以做到这一点为好。

303
00:16:08,870 --> 00:16:09,940
>> 并有冰川。

304
00:16:09,940 --> 00:16:12,670
所以，冰川是我们的
长期归档服务。

305
00:16:12,670 --> 00:16:15,050
它也被设计为
11条线路的耐用性，

306
00:16:15,050 --> 00:16:18,510
但它是当你想保存
的东西，忘掉它，对吗？

307
00:16:18,510 --> 00:16:21,690
所以，无论是合规性或其他
原因需要存档的东西，

308
00:16:21,690 --> 00:16:22,890
你应该使用冰川。

309
00:16:22,890 --> 00:16:26,210
所以冰川成本0.01美元
每月每千兆字节。

310
00:16:26,210 --> 00:16:29,550
和Amazon S3开始于
0.03美元每GB每月。

311
00:16:29,550 --> 00:16:35,274
所以冰川较便宜，
冰川需要三到五个小时

312
00:16:35,274 --> 00:16:36,190
让您的数据备份。

313
00:16:36,190 --> 00:16:37,939
所以，如果这是OK，如果
这是一个归档的情况下，

314
00:16:37,939 --> 00:16:40,970
那么冰川的可能是
正确的用例的。

315
00:16:40,970 --> 00:16:42,300
>> 再有就是存储网关。

316
00:16:42,300 --> 00:16:44,720
因此，存储网关
是在虚拟机

317
00:16:44,720 --> 00:16:50,070
你可以在本地运行
在VMware中，或Hyper-V。

318
00:16:50,070 --> 00:16:52,300
它给你一个iSCSI端点。

319
00:16:52,300 --> 00:16:54,575
然后，您可以设置
另一个VM最重要的是

320
00:16:54,575 --> 00:16:58,440
这暴露了iSCSI的
端点与CIFS或NFS。

321
00:16:58,440 --> 00:17:01,690
凡是进入该
网络共享，然后得到

322
00:17:01,690 --> 00:17:05,970
备份到亚马逊的S3，或冰川，
或者EBS取决于你如何设置它。

323
00:17:05,970 --> 00:17:10,430
所以这是一个简单的方法来
让您的数据高达AWS。

324
00:17:10,430 --> 00:17:12,510
>> 所以，再有就是我们的数据库服务。

325
00:17:12,510 --> 00:17:14,589
所以，第一个是亚马逊RDS。

326
00:17:14,589 --> 00:17:17,589
所以这是我们关系
数据库服务。

327
00:17:17,589 --> 00:17:21,420
所以这是一个管理的关系
数据库[？为了你。 ？]

328
00:17:21,420 --> 00:17:27,030
它支持SQL服务器，Oracle，
MySQL和Postgres的引擎。

329
00:17:27,030 --> 00:17:28,820
>> 它的自动故障转移。

330
00:17:28,820 --> 00:17:31,580
所以，如果你有
多AZ选项启用，

331
00:17:31,580 --> 00:17:37,070
它同步的块级
跨可用性区域复制。

332
00:17:37,070 --> 00:17:41,550
然后如果你的主
出现故障时，它会自动刚刚

333
00:17:41,550 --> 00:17:43,590
它们之间的故障切换。

334
00:17:43,590 --> 00:17:47,410
它还，为MySQL发动机，支撑
在同一区域内读取副本

335
00:17:47,410 --> 00:17:49,210
或跨区域的。

336
00:17:49,210 --> 00:17:51,720
并有各种
有趣的选项出现。

337
00:17:51,720 --> 00:17:53,200
所以它会做备份你。

338
00:17:53,200 --> 00:17:54,480
所以它会备份到S3。

339
00:17:54,480 --> 00:17:57,470
它会做你的补丁为你。

340
00:17:57,470 --> 00:17:58,900
>> 然后还有DynamoDB。

341
00:17:58,900 --> 00:18:01,740
DynamoDB是我们的管理NoSQL的服务。

342
00:18:01,740 --> 00:18:04,840
对于迪纳摩DB它带走
所有的行政负担

343
00:18:04,840 --> 00:18:09,190
为你管理的NoSQL服务。

344
00:18:09,190 --> 00:18:11,630
所以你只要提供
和你说的表

345
00:18:11,630 --> 00:18:13,380
多少读写
能力你想要的。

346
00:18:13,380 --> 00:18:15,090
它会交付给你。

347
00:18:15,090 --> 00:18:16,929
所以这是一个非常
简单的服务使用。

348
00:18:16,929 --> 00:18:17,970
然后还有ElastiCache。

349
00:18:17,970 --> 00:18:21,860
所以ElastiCache是​​我们的
托管缓存服务。

350
00:18:21,860 --> 00:18:25,010
它基本上是一个管理
Redis的或ElastiCache。

351
00:18:25,010 --> 00:18:28,830
如此反复，就可以提供集群
ElastiCache或Redis的实例

352
00:18:28,830 --> 00:18:34,240
而不必担心备份，
或故障，或任何东西。

353
00:18:34,240 --> 00:18:36,530
>> 然后，我们有我们的应用服务。

354
00:18:36,530 --> 00:18:38,770
所以CloudFront的是我们的
内容分发网络

355
00:18:38,770 --> 00:18:42,240
它生活在这些边缘位置
我谈到之前。

356
00:18:42,240 --> 00:18:44,680
所以CloudFront的可使用
对于视频直播，

357
00:18:44,680 --> 00:18:49,150
对于点播视频流，
而对于仅仅有一个网站，

358
00:18:49,150 --> 00:18:50,940
因此托管网站。

359
00:18:50,940 --> 00:18:54,270
所以你可以有网站托管
弹性负载均衡器，

360
00:18:54,270 --> 00:18:59,236
或实例，或S3水桶，
或者只是内部部署的硬件。

361
00:18:59,236 --> 00:19:01,610
你可以把一个CloudFront的
分布在它的前面。

362
00:19:01,610 --> 00:19:02,660
它会缓存您的内容。

363
00:19:02,660 --> 00:19:04,160
它会把它的边缘位置。

364
00:19:04,160 --> 00:19:06,430
所以，当有人
去你的网站

365
00:19:06,430 --> 00:19:10,100
他们会打CloudFront的，这
将要可能接近它们

366
00:19:10,100 --> 00:19:11,980
比无论产地是。

367
00:19:11,980 --> 00:19:15,600
它会卸载了很多
负载过原点，

368
00:19:15,600 --> 00:19:22,600
这样既节省了你的钱，
获得更好的用户体验。

369
00:19:22,600 --> 00:19:24,780
>> 再有就是亚马逊CloudSearch。

370
00:19:24,780 --> 00:19:26,810
所以CloudSearch是
管理搜索服务。

371
00:19:26,810 --> 00:19:30,510
所以，你把它的搜索
数据和交谈它通过一个API，

372
00:19:30,510 --> 00:19:32,710
它会为你做搜索结果。

373
00:19:32,710 --> 00:19:34,530
再有就是弹性转码器。

374
00:19:34,530 --> 00:19:36,530
所以这是一个管理的转码解决方案。

375
00:19:36,530 --> 00:19:41,050
你把你的视频转换为S3桶，
告诉它转码成，

376
00:19:41,050 --> 00:19:45,460
什么格式，什么
大小和一切。

377
00:19:45,460 --> 00:19:49,470
它会转码，并把
它变成一个S3桶你。

378
00:19:49,470 --> 00:19:52,600
>> 再有就是我们的大数据服务。

379
00:19:52,600 --> 00:19:55,780
所以，我们已经得到了亚马逊电子病历，
这是弹性的Map Reduce。

380
00:19:55,780 --> 00:19:58,200
所以这是一个托管的Hadoop框架。

381
00:19:58,200 --> 00:20:02,920
所以，你可以旋转起来在Hadoop集群
一个实例数百实例

382
00:20:02,920 --> 00:20:04,030
如果你需要的。

383
00:20:04,030 --> 00:20:06,975
它得到了深度整合
S3中，以便为它的文件系统

384
00:20:06,975 --> 00:20:09,830
你可以使用HDSF，你
传统上做用Hadoop。

385
00:20:09,830 --> 00:20:12,870
或者你可以做S3作为文件系统。

386
00:20:12,870 --> 00:20:15,240
>> 它有支持
现货价格，这一点，

387
00:20:15,240 --> 00:20:19,110
在亚马逊，你怎么出价
对于产能过剩。

388
00:20:19,110 --> 00:20:20,840
因此，它支持了这一切。

389
00:20:20,840 --> 00:20:26,670
它支持常见的Hadoop框架
如Spark和鲨鱼和蜂巢

390
00:20:26,670 --> 00:20:28,460
和猪。

391
00:20:28,460 --> 00:20:32,950
我们已经看到过5.5
百万EMR集群

392
00:20:32,950 --> 00:20:35,340
在这一点上亚马逊推出。

393
00:20:35,340 --> 00:20:38,338
>> 然后，我们已经有了AWS数据管道。

394
00:20:38,338 --> 00:20:40,213
因此，数据管道是
服务，这将允许

395
00:20:40,213 --> 00:20:42,296
你跨移动数据
我们不同的数据存储。

396
00:20:42,296 --> 00:20:48,030
所以，你可以从S3的东西，把
成RDS，然后做一些EMR就可以了，

397
00:20:48,030 --> 00:20:50,760
放入红移，这是
我们的数据仓库设备，

398
00:20:50,760 --> 00:20:54,564
然后你可以拉出来的东西
的前提上，MySQL实例。

399
00:20:54,564 --> 00:20:56,730
因此，有各种
事情可以做的。

400
00:20:56,730 --> 00:20:57,646
>> 再有就是红移。

401
00:20:57,646 --> 00:21:00,470
红移是我们的管理
数据仓库设备。

402
00:21:00,470 --> 00:21:04,880
它的意思是PB级规模，因此
你可以存储大量的有关它的数据。

403
00:21:04,880 --> 00:21:07,280
这是一个大规模并行架构。

404
00:21:07,280 --> 00:21:10,040
所以，你可以有很多
节点，如果你想。

405
00:21:10,040 --> 00:21:13,509
和它的所有备份和所有
行政的东西给你。

406
00:21:13,509 --> 00:21:14,550
然后还有室壁运动。

407
00:21:14,550 --> 00:21:17,340
室壁运动是我们的实时
加工服务。

408
00:21:17,340 --> 00:21:20,970
所以，你可以采取一些源
实时流数据，

409
00:21:20,970 --> 00:21:27,360
所以说，像Twitter的流水，或
一堆的日志数据，将其发送给室壁运动。

410
00:21:27,360 --> 00:21:29,140
室壁运动处理所有为你。

411
00:21:29,140 --> 00:21:32,250
然后你就可以连接
工人把它拉出来的东西

412
00:21:32,250 --> 00:21:36,340
并说，做一个现场的仪表板
或做就可以了现场分析。

413
00:21:36,340 --> 00:21:38,330
>> 这样的话，我们有我们的部署服务。

414
00:21:38,330 --> 00:21:42,530
因此AWS OpsWorks是一个DevOps的框架。

415
00:21:42,530 --> 00:21:45,237
所以，你把你的应用程序，
你打破它成层。

416
00:21:45,237 --> 00:21:48,195
所以，你有你的负载平衡器
层，你的web层，你的应用程序层，

417
00:21:48,195 --> 00:21:51,590
你的数据库层，你
在这些层提供的东西

418
00:21:51,590 --> 00:21:53,720
根据厨师的食谱。

419
00:21:53,720 --> 00:21:56,280
厨师是一个配置
管理系统。

420
00:21:56,280 --> 00:21:59,530
因此它也支持
生命周期事件等

421
00:21:59,530 --> 00:22:01,820
如果你不希望管理
你自己的厨师，对不对，

422
00:22:01,820 --> 00:22:04,570
如果你想有某种
编程的方式来部署的事情

423
00:22:04,570 --> 00:22:07,420
到你的情况下，这
是一种选择适合你。

424
00:22:07,420 --> 00:22:09,030
>> 然后我们有弹性魔豆。

425
00:22:09,030 --> 00:22:16,030
所以弹性魔豆是一种服务，
让你to--说你是一名开发人员。

426
00:22:16,030 --> 00:22:18,630
你有一个Git回购你的代码。

427
00:22:18,630 --> 00:22:22,030
你不希望有担心
有关部署自己ELBs或RDS

428
00:22:22,030 --> 00:22:24,500
实例或定期EC2实例。

429
00:22:24,500 --> 00:22:29,050
所以你要做的就是你，从你的代码，
只需将它发送到弹性魔豆。

430
00:22:29,050 --> 00:22:33,310
弹性魔豆将提供RDS
实例和ELBs和所有的东西

431
00:22:33,310 --> 00:22:35,556
为您和您的代码部署到他们。

432
00:22:35,556 --> 00:22:37,305
所以它使很多
开发人员更容易

433
00:22:37,305 --> 00:22:40,600
来部署他们的代码到AWS。

434
00:22:40,600 --> 00:22:41,910
>> 然后还有CloudFormation。

435
00:22:41,910 --> 00:22:47,310
所以CloudFormation是一个服务
治疗你的基础设施代码。

436
00:22:47,310 --> 00:22:50,280
所以，现在你有这一切
东西在你的应用程序，

437
00:22:50,280 --> 00:22:52,680
你有你的VPC，并
您的安全组规则，

438
00:22:52,680 --> 00:22:56,000
和你的EC2实例，
和你的RDS实例。

439
00:22:56,000 --> 00:22:58,130
所以，你有这整个
架构上的AWS。

440
00:22:58,130 --> 00:23:01,340
那么，编程你怎么了
旋转的或重新创建？

441
00:23:01,340 --> 00:23:04,170
你可以写一个JSON文件
它代表了这一切。

442
00:23:04,170 --> 00:23:05,920
然后你就可以
[？走？]认为JSON文件

443
00:23:05,920 --> 00:23:08,180
和部署
基础设施的关闭它。

444
00:23:08,180 --> 00:23:10,930
所以，你可以有一个架构
在那里，每次部署的代码的时候，

445
00:23:10,930 --> 00:23:14,560
它旋转了你的整个的全新副本
建筑和故障转移到它。

446
00:23:14,560 --> 00:23:19,130
所以，你也可以做到这一点，以
有一个可变的基础设施。

447
00:23:19,130 --> 00:23:21,970
>> 后来终于有我们的
管理服务。

448
00:23:21,970 --> 00:23:25,270
因此，我们的管理服务
开始与亚马逊IAM，

449
00:23:25,270 --> 00:23:27,410
所以它的身份和访问管理。

450
00:23:27,410 --> 00:23:30,150
这样可以让你
管理您的AWS账户

451
00:23:30,150 --> 00:23:32,290
这样你就可以有子
用户和组，做

452
00:23:32,290 --> 00:23:34,330
身份联盟
和各种东西。

453
00:23:34,330 --> 00:23:36,690
这对于安全真的很重要。

454
00:23:36,690 --> 00:23:39,440
>> 然后我们有亚马逊的CloudWatch，
这是我们的衡量标准的服务。

455
00:23:39,440 --> 00:23:41,956
所以，它给你的CPU使用率
和各种指标。

456
00:23:41,956 --> 00:23:44,080
你可以做定制
度量和[？你可以做什么？]

457
00:23:44,080 --> 00:23:47,050
根据这些指标自动缩放。

458
00:23:47,050 --> 00:23:48,450
>> 然后我们有CloudTrail。

459
00:23:48,450 --> 00:23:50,680
所以CloudTrail是我们的
服务审计。

460
00:23:50,680 --> 00:23:54,380
因此，它会记录API调用
对亚马逊网络服务。

461
00:23:54,380 --> 00:23:56,560
那么，谁重启这种情况？

462
00:23:56,560 --> 00:23:58,060
谁改变了这个安全组？

463
00:23:58,060 --> 00:23:59,810
并记录成
必要的水桶所以你

464
00:23:59,810 --> 00:24:03,650
可以看到发生了什么
您的帐户，谁做的。

465
00:24:03,650 --> 00:24:05,600
>> 新的服务，我们
已经是工作区。

466
00:24:05,600 --> 00:24:08,530
所以这是在AWS桌面虚拟化。

467
00:24:08,530 --> 00:24:13,290
所以，你可以提供一个
工作站，Windows工作站，

468
00:24:13,290 --> 00:24:17,810
它会再过来
在几分钟。

469
00:24:17,810 --> 00:24:21,470
它会连接到您的活动
目录中，所以你的用户。

470
00:24:21,470 --> 00:24:23,580
您可以轻松地重建它。

471
00:24:23,580 --> 00:24:25,090
您可以轻松地提供一个新的。

472
00:24:25,090 --> 00:24:28,250
有不同的类型与
不同的软件在那里。

473
00:24:28,250 --> 00:24:30,740
>> 所以，现在，我们已经经历了
很多我们的服务，让我们

474
00:24:30,740 --> 00:24:31,850
做一个实际的现场演示。

475
00:24:31,850 --> 00:24:35,700
所以我要切换
在这里我的网页浏览器。

476
00:24:35,700 --> 00:24:41,270
所以，我想告诉你
如何快速建立

477
00:24:41,270 --> 00:24:43,690
一个EC2实例与WordPress的就可以了。

478
00:24:43,690 --> 00:24:45,440
然后我们要去
做同样的事情，

479
00:24:45,440 --> 00:24:48,890
但我们要旋转起来
一个RDS实例和ELB。

480
00:24:48,890 --> 00:24:52,690
所以我们会做的只是在实例和
我们将打破所有的层出为好。

481
00:24:52,690 --> 00:24:54,510
>> 所以，让我们启动一个EC2实例。

482
00:24:54,510 --> 00:24:57,190
所以第一件事，
我已经在这里做了

483
00:24:57,190 --> 00:24:59,230
是你会想
有一个密钥对。

484
00:24:59,230 --> 00:25:03,576
因此，一个密钥对，您可以来
登录到实际的实例。

485
00:25:03,576 --> 00:25:05,450
所以你保持私有
密钥对的一部分，

486
00:25:05,450 --> 00:25:08,570
我们把公众
部分上的实例。

487
00:25:08,570 --> 00:25:11,700
而这正是让你登录。

488
00:25:11,700 --> 00:25:16,330
所以，我已导入我的密钥对，
只是我经常SSH密钥这里对。

489
00:25:16,330 --> 00:25:19,290
>> 所以其他的事情
我要在这里做的是，

490
00:25:19,290 --> 00:25:22,214
我已经有一些实例
跑步，但我会推出一个新的。

491
00:25:22,214 --> 00:25:24,130
所以我要来接我
这里操作系统。

492
00:25:24,130 --> 00:25:27,970
所以你可以看到我有一个漂亮
大选择的操作系统。

493
00:25:27,970 --> 00:25:31,015
所以我只是要挑
您的标准亚马逊的Linux。

494
00:25:31,015 --> 00:25:32,930
>> 而且我要选择一个实例类型。

495
00:25:32,930 --> 00:25:35,890
而由于这是一个
Web服务器，我要去

496
00:25:35,890 --> 00:25:39,540
做c3.large，因为它是
大概计算密集型。

497
00:25:39,540 --> 00:25:45,210
所以，我要选择一个c3.large，
我要去发动他们中的一个。

498
00:25:45,210 --> 00:25:48,630
我打算把它留在
默认VPC现在。

499
00:25:48,630 --> 00:25:50,810
我要离开这一切的东西孤单。

500
00:25:50,810 --> 00:25:53,270
>> 我要去，使
监测的CloudWatch

501
00:25:53,270 --> 00:25:56,204
因为详细的CloudWatch
监测变化的CloudWatch

502
00:25:56,204 --> 00:25:58,870
从五分钟的监测
决议一分钟的分辨率。

503
00:25:58,870 --> 00:26:02,510
所以，我想这与我在这里的Web服务器。

504
00:26:02,510 --> 00:26:05,220
然后我会去的存储。

505
00:26:05,220 --> 00:26:08,710
所以我想在这里对通用SSD。

506
00:26:08,710 --> 00:26:11,940
8音乐会大概是足以让我，
所以我只是要保持这一点。

507
00:26:11,940 --> 00:26:16,360

508
00:26:16,360 --> 00:26:19,230
我只是要标注
这WordPress的演示。

509
00:26:19,230 --> 00:26:22,149
因此，这是标签，所以我
知道它实际上是什么。

510
00:26:22,149 --> 00:26:24,190
然后我要去
配置安全组。

511
00:26:24,190 --> 00:26:27,510
因此，安全组就像是
防火墙的实例。

512
00:26:27,510 --> 00:26:30,780
所以我打算用一
我现有的。

513
00:26:30,780 --> 00:26:35,890
所以这个安全组时，
使SSH，这样我就可以SSH到它。

514
00:26:35,890 --> 00:26:37,580
它使HTTP。

515
00:26:37,580 --> 00:26:40,390
>> 现在，我将要锁定
下来的SSH多一点点。

516
00:26:40,390 --> 00:26:43,220
你不想只是任何人
来自任何IP地址ssh方式连接。

517
00:26:43,220 --> 00:26:45,240
所以我们会做它启动后。

518
00:26:45,240 --> 00:26:49,100
>> 所以，我很高兴与所有
这个东西在这里。

519
00:26:49,100 --> 00:26:50,167
我要去发动。

520
00:26:50,167 --> 00:26:52,250
然后我要去
选择我想要的密钥对。

521
00:26:52,250 --> 00:26:54,750
所以我要选择
我之前更新密钥对。

522
00:26:54,750 --> 00:26:57,570

523
00:26:57,570 --> 00:27:01,960
>> 所以，现在我在等待
它推出，让我们

524
00:27:01,960 --> 00:27:03,320
去看看我们的安全组。

525
00:27:03,320 --> 00:27:06,720
所以，现在我们得到的安全组。

526
00:27:06,720 --> 00:27:09,550
这里是我的安全
我把它放在组。

527
00:27:09,550 --> 00:27:11,200
>> 我打算就在这里改变这一点。

528
00:27:11,200 --> 00:27:15,710
因此，让我这样的
这里有点大。

529
00:27:15,710 --> 00:27:21,275
所以我想改变这个
从任何地方到我的IP。

530
00:27:21,275 --> 00:27:23,150
因为这将
自动拿起我的IP

531
00:27:23,150 --> 00:27:26,650
在这里讨论并锁定
下来一点点。

532
00:27:26,650 --> 00:27:29,030
>> 等而
实例旋转了起来，

533
00:27:29,030 --> 00:27:32,040
让我们旋转起来一些东西
我们的另一个实例

534
00:27:32,040 --> 00:27:35,060
我们要去的地方打出来
数据库和负载平衡器

535
00:27:35,060 --> 00:27:37,160
因此，它可以为我们准备好。

536
00:27:37,160 --> 00:27:41,580
所以，第一件事我会想
做的是旋转起来的负载平衡器。

537
00:27:41,580 --> 00:27:44,690
所以我要选择
负载均衡器在这里。

538
00:27:44,690 --> 00:27:48,410
而且我要叫它WordpressELB。

539
00:27:48,410 --> 00:27:52,106

540
00:27:52,106 --> 00:27:55,450
而且我要just--所有
我要的是80端口在这里。

541
00:27:55,450 --> 00:27:57,960
>> 而对于现在健康
检查，我只是打算做TCP。

542
00:27:57,960 --> 00:28:00,190
所以，如果Apache的运行，这将是很好的。

543
00:28:00,190 --> 00:28:03,760
我要去降低健康
阈值刚好，使其成为健康

544
00:28:03,760 --> 00:28:06,360
很快。

545
00:28:06,360 --> 00:28:08,710
然后，再次，这有一个安全组。

546
00:28:08,710 --> 00:28:12,480
所以，我已经做了一个安全
组这款名为WordPress的ELB。

547
00:28:12,480 --> 00:28:17,120
而且它基本上只是去
接受端口80的流量。

548
00:28:17,120 --> 00:28:19,580
然后我不会加
它的任何实例现在。

549
00:28:19,580 --> 00:28:22,290

550
00:28:22,290 --> 00:28:26,720
我要去跳过标记。

551
00:28:26,720 --> 00:28:30,010
所以我们要
现在创建这个ELB。

552
00:28:30,010 --> 00:28:33,800
>> 这样产生的负载平衡器。

553
00:28:33,800 --> 00:28:36,680
我也将推出
多了一个实例在这里，

554
00:28:36,680 --> 00:28:40,280
只是我的WordPress的网络的一部分。

555
00:28:40,280 --> 00:28:42,580
所以在这里我们去。

556
00:28:42,580 --> 00:28:45,920
我只是做同样的
事我以前那样。

557
00:28:45,920 --> 00:28:53,620
所以c3.large，CloudWatch的
详细的监测功能。

558
00:28:53,620 --> 00:28:56,290

559
00:28:56,290 --> 00:28:57,310
通用固态硬盘。

560
00:28:57,310 --> 00:29:02,470

561
00:29:02,470 --> 00:29:05,590
调用这个WordPress网站。

562
00:29:05,590 --> 00:29:11,440

563
00:29:11,440 --> 00:29:14,480
>> 我想选择A--我已经
有一个安全组这一点。

564
00:29:14,480 --> 00:29:18,320

565
00:29:18,320 --> 00:29:23,520
所以这个安全组接受交通
在端口80从我的WordPress ELB

566
00:29:23,520 --> 00:29:26,430
安全组，从安全
从我的负载均衡组，

567
00:29:26,430 --> 00:29:30,654
而且SSH，它再次
我们要锁定。

568
00:29:30,654 --> 00:29:31,820
所以我打算推出这一点。

569
00:29:31,820 --> 00:29:39,360

570
00:29:39,360 --> 00:29:39,990
正确的。

571
00:29:39,990 --> 00:29:43,530
>> 然后就是我要做的就是下一个
我要发起一个RDS实例。

572
00:29:43,530 --> 00:29:44,870
RDS将是我的数据库。

573
00:29:44,870 --> 00:29:47,100
所以我要去这里。

574
00:29:47,100 --> 00:29:48,560
我要去RDS。

575
00:29:48,560 --> 00:29:52,800

576
00:29:52,800 --> 00:29:56,239
我要推出一个新的实例。

577
00:29:56,239 --> 00:29:57,530
所以我要来接我的引擎。

578
00:29:57,530 --> 00:30:00,850
所以在这里我有MySQL的一个选择，
Postgres的，Oracle或SQL Server中。

579
00:30:00,850 --> 00:30:02,640
我想的MySQL。

580
00:30:02,640 --> 00:30:06,160
所以我会说是的。

581
00:30:06,160 --> 00:30:09,680
>> 因此，这是对多AZ一个选项。

582
00:30:09,680 --> 00:30:14,267
所以，多AZ，再次重复那些
是要旋转两个RDS实例

583
00:30:14,267 --> 00:30:15,600
做他们之间的复制。

584
00:30:15,600 --> 00:30:20,510
如果我不希望我可以有
一个实例，但我不希望出现这种情况。

585
00:30:20,510 --> 00:30:22,490
然后我要去
接我的数据库引擎。

586
00:30:22,490 --> 00:30:24,907
所以我会挑
这里最新的一个。

587
00:30:24,907 --> 00:30:27,240
然后我会挑
我想要什么类型的实例。

588
00:30:27,240 --> 00:30:30,950
>> 所以，我希望有一个R3，所以这是
内存优化实例。

589
00:30:30,950 --> 00:30:32,740
所以，我要挑R3。

590
00:30:32,740 --> 00:30:35,430
而且我会挑
是的，我想多AZ。

591
00:30:35,430 --> 00:30:37,110
我想通用SSD。

592
00:30:37,110 --> 00:30:39,380
>> 我可能想要一个
点点更多的存储。

593
00:30:39,380 --> 00:30:40,897
我将有10个演出在这里。

594
00:30:40,897 --> 00:30:42,730
然后我要去
挑选一些凭证。

595
00:30:42,730 --> 00:30:44,641
那么什么是标识符我的数据库？

596
00:30:44,641 --> 00:30:46,015
因此，这将是wordpressdb1。

597
00:30:46,015 --> 00:30:50,725

598
00:30:50,725 --> 00:30:53,127
我要叫这个根。

599
00:30:53,127 --> 00:30:54,460
我要去给它一个密码。

600
00:30:54,460 --> 00:30:58,380

601
00:30:58,380 --> 00:31:03,780
>> 而且我们要挑
安全组这一点。

602
00:31:03,780 --> 00:31:05,740
所以，我已经做了
安全组此。

603
00:31:05,740 --> 00:31:08,400

604
00:31:08,400 --> 00:31:11,307
然后我要去
给它一个数据库名。

605
00:31:11,307 --> 00:31:13,015
所以我们要只
称之为WordPress的。

606
00:31:13,015 --> 00:31:16,727

607
00:31:16,727 --> 00:31:18,560
我们要去
选择一个固定的窗口

608
00:31:18,560 --> 00:31:21,170
所以，这确实备份你。

609
00:31:21,170 --> 00:31:23,330
所以我想一个星期的备份。

610
00:31:23,330 --> 00:31:25,610
我没有偏好
备份窗口。

611
00:31:25,610 --> 00:31:28,665
我希望它会自动
在这里我升级次要版本。

612
00:31:28,665 --> 00:31:31,180
所以我要离开，作为默认值。

613
00:31:31,180 --> 00:31:33,490
所以现在我展开
我的RDS实例。

614
00:31:33,490 --> 00:31:37,370

615
00:31:37,370 --> 00:31:37,870
对不对？

616
00:31:37,870 --> 00:31:40,597
所以，现在它被创建。

617
00:31:40,597 --> 00:31:42,430
所以，现在我们只是在等待
对于它进行安装。

618
00:31:42,430 --> 00:31:48,055
因此，尽管这是怎么回事，让我们登录
到第一个EC2实例中我们做了。

619
00:31:48,055 --> 00:31:55,090

620
00:31:55,090 --> 00:31:57,520
所以它的这个WordPress的演示。

621
00:31:57,520 --> 00:31:58,760
我们将只验证。

622
00:31:58,760 --> 00:31:59,450
是的。

623
00:31:59,450 --> 00:32:02,620
>> 因此，让我们看看我们是否可以把它记录。

624
00:32:02,620 --> 00:32:06,220
所以我要去复制
它的公共主机名。

625
00:32:06,220 --> 00:32:09,090
我要去开拓
一个shell窗口在这里。

626
00:32:09,090 --> 00:32:14,480

627
00:32:14,480 --> 00:32:17,610
[听不清] SSH。

628
00:32:17,610 --> 00:32:21,423
默认用户是EC2用户。

629
00:32:21,423 --> 00:32:25,271
>> 听众：狮子座，你会
心中命令[听不清]？

630
00:32:25,271 --> 00:32:27,200
>> LEO ZHADANOVSKY：好？

631
00:32:27,200 --> 00:32:30,190
所以让我们尝试SSH英寸

632
00:32:30,190 --> 00:32:30,960
是的。

633
00:32:30,960 --> 00:32:34,420
所以，我在我的实例现在。

634
00:32:34,420 --> 00:32:36,550
所以我SSHed英寸

635
00:32:36,550 --> 00:32:38,970
它是由五分钟，
这绝对是我的实例。

636
00:32:38,970 --> 00:32:41,020
>> 所以，第一件事我们
将要在这里做

637
00:32:41,020 --> 00:32:45,190
是它告诉我说，哦，
我有一些安全更新。

638
00:32:45,190 --> 00:32:47,855
所以，我只是要运行
在这里的每一个安全更新。

639
00:32:47,855 --> 00:32:51,746
[？须藤荫？]减Y更新。

640
00:32:51,746 --> 00:32:54,539
所以它要快速安装这些。

641
00:32:54,539 --> 00:32:57,080
接下来的事情，我要做的是我
要安装一些更多的东西。

642
00:32:57,080 --> 00:33:00,910
所以我将不得不安装MySQL。

643
00:33:00,910 --> 00:33:02,660
我将不得不安装Apache。

644
00:33:02,660 --> 00:33:04,190
我将必须安装PHP。

645
00:33:04,190 --> 00:33:07,680
我将不得不安装
PHP的插件为MySQL。

646
00:33:07,680 --> 00:33:11,100
我必须安装MySQL服务器。

647
00:33:11,100 --> 00:33:12,440
因此，让我们安装这个东西。

648
00:33:12,440 --> 00:33:14,980

649
00:33:14,980 --> 00:33:15,500
>> 安装。

650
00:33:15,500 --> 00:33:16,770
所以这样做了。

651
00:33:16,770 --> 00:33:20,220
所以现在我想[？ HTTPD。 ？]我
希望Apache将开始启动。

652
00:33:20,220 --> 00:33:21,380
所以，我要做到这一点。

653
00:33:21,380 --> 00:33:29,250

654
00:33:29,250 --> 00:33:29,750
好不好。

655
00:33:29,750 --> 00:33:31,800
所以，现在，如果我重新启动这一点，就会开始。

656
00:33:31,800 --> 00:33:36,210
>> 我也希望MySQL开始启动。

657
00:33:36,210 --> 00:33:37,615
所以，同样的事情。

658
00:33:37,615 --> 00:33:41,784

659
00:33:41,784 --> 00:33:45,080
哎呀，错字这里。

660
00:33:45,080 --> 00:33:45,580
行。

661
00:33:45,580 --> 00:33:53,220
然后其实我会
后来我开始的Web服务器。

662
00:33:53,220 --> 00:33:56,514
现在我要开始我的
数据库服务器，虽然。

663
00:33:56,514 --> 00:33:57,906
所以做到这一点。

664
00:33:57,906 --> 00:34:01,618

665
00:34:01,618 --> 00:34:04,120
所以它开始了
第一次，所以我

666
00:34:04,120 --> 00:34:06,070
不得不做
这里的一些基本步骤。

667
00:34:06,070 --> 00:34:09,070
所以，第一件事我会做
设置为我的MySQL root密码。

668
00:34:09,070 --> 00:34:15,980
>> 所以，我只是要运行这个MySQL
安全的安装命令。

669
00:34:15,980 --> 00:34:19,239
因此它有没有当前的根
密码，因此让我们设置之一。

670
00:34:19,239 --> 00:34:24,830

671
00:34:24,830 --> 00:34:27,429
而且我要删除这些
它创建匿名用户

672
00:34:27,429 --> 00:34:29,750
并禁止root登录。

673
00:34:29,750 --> 00:34:31,270
并删除测试数据库。

674
00:34:31,270 --> 00:34:36,514
所以这种所有
productionizes你的MySQL安装。

675
00:34:36,514 --> 00:34:38,260
>> 所以这样做了。

676
00:34:38,260 --> 00:34:40,630
所以，现在我应该能
连接到我的MySQL服务器。

677
00:34:40,630 --> 00:34:42,805
所以，我要看看是否能在这里工作。

678
00:34:42,805 --> 00:34:46,030

679
00:34:46,030 --> 00:34:46,530
是的。

680
00:34:46,530 --> 00:34:50,699
所以，我在我的MySQL服务器。

681
00:34:50,699 --> 00:34:55,010
>> 所以，现在的未来的事情我想要做的就是
我要创建我的WordPress的数据库。

682
00:34:55,010 --> 00:34:56,429
所以我打算做MySQL管理。

683
00:34:56,429 --> 00:35:09,845

684
00:35:09,845 --> 00:35:10,345
[听不清]

685
00:35:10,345 --> 00:35:13,327

686
00:35:13,327 --> 00:35:13,840
行。

687
00:35:13,840 --> 00:35:15,520
所以，我创造了我的数据库。

688
00:35:15,520 --> 00:35:18,160
>> 现在我想要做的就是我
要创建一个WordPress的用户。

689
00:35:18,160 --> 00:35:20,240
所以，我不想登录
我的WordPress的root用户

690
00:35:20,240 --> 00:35:21,420
因为那会很糟糕。

691
00:35:21,420 --> 00:35:24,810
所以，我希望用户只能
访问WordPress的数据库。

692
00:35:24,810 --> 00:35:27,970
所以，让我们在这里。

693
00:35:27,970 --> 00:35:33,720
而且我们要[？移动？]这个位置。

694
00:35:33,720 --> 00:35:36,870
>> 所以我在做什么这里是
我创建一个用户的

695
00:35:36,870 --> 00:35:40,220
可以从本地主机这是连接
确定我的超级安全密码

696
00:35:40,220 --> 00:35:42,510
这里。

697
00:35:42,510 --> 00:35:46,595
然后我要授予此
用户访问整个数据库。

698
00:35:46,595 --> 00:35:51,091

699
00:35:51,091 --> 00:35:51,590
行。

700
00:35:51,590 --> 00:35:56,200
然后现在我应该是
能够以该用户登录

701
00:35:56,200 --> 00:35:58,670
只有看到数据库
[？和？]测试数据库。

702
00:35:58,670 --> 00:36:04,970
>> 所以我打算做MySQL的减
üWordPress的，而不是根。

703
00:36:04,970 --> 00:36:10,360

704
00:36:10,360 --> 00:36:10,860
行？

705
00:36:10,860 --> 00:36:16,920
然后我们要
能够do--吧？

706
00:36:16,920 --> 00:36:18,740
这样我就可以在这里看到我的WordPress的数据库。

707
00:36:18,740 --> 00:36:19,920
所以，这是伟大的。

708
00:36:19,920 --> 00:36:22,420
>> 所以，现在我们需要实际
下载并安装的WordPress。

709
00:36:22,420 --> 00:36:26,220
因此，让我们去我们的网站目录。

710
00:36:26,220 --> 00:36:31,760
所以，我要wget的WordPress的，在
最新版本的WordPress这里。

711
00:36:31,760 --> 00:36:36,100

712
00:36:36,100 --> 00:36:37,320
我要提取。

713
00:36:37,320 --> 00:36:42,195

714
00:36:42,195 --> 00:36:44,690
现在我要去换
HTML目录，其中

715
00:36:44,690 --> 00:36:48,150
是默认的[？网络？]根，
与WordPress的目录，因此。

716
00:36:48,150 --> 00:37:01,650

717
00:37:01,650 --> 00:37:02,410
>> 行。

718
00:37:02,410 --> 00:37:06,580
现在我要去只是改变
权限，以便在Apache

719
00:37:06,580 --> 00:37:09,450
用户拥有的WordPress的目录。

720
00:37:09,450 --> 00:37:12,611

721
00:37:12,611 --> 00:37:13,110
行。

722
00:37:13,110 --> 00:37:17,070
最后，我要开始我的
Web服务器，并希望一切正常。

723
00:37:17,070 --> 00:37:21,650

724
00:37:21,650 --> 00:37:22,150
行。

725
00:37:22,150 --> 00:37:23,940
所以，现在让我们看看会发生什么。

726
00:37:23,940 --> 00:37:28,520
所以我要去这里。

727
00:37:28,520 --> 00:37:30,700
看看，如果我能得到
到这里该实例。

728
00:37:30,700 --> 00:37:35,200

729
00:37:35,200 --> 00:37:35,740
行。

730
00:37:35,740 --> 00:37:39,860
因此，这里是我们的WordPress安装屏幕。

731
00:37:39,860 --> 00:37:42,020
因此，我们知道所有这些信息。

732
00:37:42,020 --> 00:37:44,170
因此，我们的数据库名是WordPress的。

733
00:37:44,170 --> 00:37:47,550
>> 我们的用户名将会是WordPress的。

734
00:37:47,550 --> 00:37:50,462
我这里有我的超级安全的密码。

735
00:37:50,462 --> 00:37:53,869
我们将要
连接到本地主机。

736
00:37:53,869 --> 00:37:58,040
而且我们要运行安装。

737
00:37:58,040 --> 00:38:00,430
>> 现在我们只是要
给我的网站的名称。

738
00:38:00,430 --> 00:38:04,600
所以狮子座的惊人博客。

739
00:38:04,600 --> 00:38:08,265

740
00:38:08,265 --> 00:38:12,580
[听不清]用户名。

741
00:38:12,580 --> 00:38:15,972
我要得到一个
密码我的用户名。

742
00:38:15,972 --> 00:38:18,979

743
00:38:18,979 --> 00:38:20,520
我要去把我的电子邮件地址。

744
00:38:20,520 --> 00:38:23,790

745
00:38:23,790 --> 00:38:29,326
而且因为它是一个测试一个，我不
希望搜索引擎索引了。

746
00:38:29,326 --> 00:38:30,820
所以，现在我们正在安装的WordPress。

747
00:38:30,820 --> 00:38:32,070
所以，现在我们都设定。

748
00:38:32,070 --> 00:38:33,850
>> 因此，这里是我的WordPress。

749
00:38:33,850 --> 00:38:37,660

750
00:38:37,660 --> 00:38:40,345
这是我的仪表板。

751
00:38:40,345 --> 00:38:42,300
这是一个全功能的WordPress的。

752
00:38:42,300 --> 00:38:47,026
我可以更新插件
在这里，如果我想。

753
00:38:47,026 --> 00:38:49,290
做任何我想在这里。

754
00:38:49,290 --> 00:38:52,610
所以这里是我的真实完全
我的一个实例运行WordPress的。

755
00:38:52,610 --> 00:38:55,760
>> 现在，这是伟大的，如果你有一个
测试部位，但是这不能扩展。

756
00:38:55,760 --> 00:38:56,737
我们有一个实例。

757
00:38:56,737 --> 00:38:59,070
我们可以作出这样的实例
真正巨大的，但在某些时候

758
00:38:59,070 --> 00:39:01,165
你要出去跑
垂直缩放室。

759
00:39:01,165 --> 00:39:03,290
所以，你会想
它的规模比这更。

760
00:39:03,290 --> 00:39:05,290
>> 这就是为什么我们剥离了
这一切其他的东西。

761
00:39:05,290 --> 00:39:07,620
所以，如果让我们来看看我们的
RDS实例已经完成。

762
00:39:07,620 --> 00:39:13,500

763
00:39:13,500 --> 00:39:16,170
[？是的，？]我们的RDS
例如几乎完成。

764
00:39:16,170 --> 00:39:19,520
所以，这是因为在此期间确定
我们可以设置我们的EC2实例。

765
00:39:19,520 --> 00:39:22,670
这将只是一个
稍有不同的程序。

766
00:39:22,670 --> 00:39:24,940
>> 因此，我们有我们的WordPress网站。

767
00:39:24,940 --> 00:39:28,540
现在，我已经有一个正在运行的昨天。

768
00:39:28,540 --> 00:39:33,670
所以，我刚刚拿到了找出哪些
一个是它是我今天开通。

769
00:39:33,670 --> 00:39:36,710
所以，这一次推出11月4日。

770
00:39:36,710 --> 00:39:39,370

771
00:39:39,370 --> 00:39:40,770
所以这是从今天之一。

772
00:39:40,770 --> 00:39:43,720
[？我知道？]这个是
推出的，哦，4:00 PM。

773
00:39:43,720 --> 00:39:45,905
所以实际上这是新的。

774
00:39:45,905 --> 00:39:51,474

775
00:39:51,474 --> 00:39:51,974
是的。

776
00:39:51,974 --> 00:39:52,930
好不好。

777
00:39:52,930 --> 00:39:54,590
>> 所以这是我的新实例。

778
00:39:54,590 --> 00:39:56,110
所以，再一次，我要SSH到它。

779
00:39:56,110 --> 00:40:01,550

780
00:40:01,550 --> 00:40:05,630
因此，让我们回到我的终端在这里。

781
00:40:05,630 --> 00:40:08,350
所以，我要走出这一个。

782
00:40:08,350 --> 00:40:11,232
我要SSH到新的实例。

783
00:40:11,232 --> 00:40:15,160

784
00:40:15,160 --> 00:40:15,660
行。

785
00:40:15,660 --> 00:40:17,951
所以我不得不做
这里的一些相同的东西。

786
00:40:17,951 --> 00:40:19,540
所以，我要运行安全更新。

787
00:40:19,540 --> 00:40:23,790

788
00:40:23,790 --> 00:40:25,654
我要安装一些软件包。

789
00:40:25,654 --> 00:40:27,820
该软件包将
略有不同了。

790
00:40:27,820 --> 00:40:31,660
>> 所以我不需要MySQL服务器
因为我们打破了这一点。

791
00:40:31,660 --> 00:40:35,580
所以，我仍然会
安装MySQL客户端。

792
00:40:35,580 --> 00:40:37,400
我还是会安装Apache。

793
00:40:37,400 --> 00:40:40,142
我仍然会
安装PHP和MySQL的PHP​​。

794
00:40:40,142 --> 00:40:42,100
我只是不打算
安装MySQL服务器。

795
00:40:42,100 --> 00:40:44,640

796
00:40:44,640 --> 00:40:50,203
>> 然后，我仍然会做
确保Apache就开始启动。

797
00:40:50,203 --> 00:40:55,890

798
00:40:55,890 --> 00:40:57,790
现在，我们需要在数据库待涨。

799
00:40:57,790 --> 00:41:02,140
所以，当我们做到这一点，让我们添加这
实例的负载平衡器。

800
00:41:02,140 --> 00:41:04,610
因此，我们打算去
我们的负载均衡器在这里。

801
00:41:04,610 --> 00:41:08,430
我们只是要
复制下来的实例ID。

802
00:41:08,430 --> 00:41:10,410
这里有我的实​​例ID。

803
00:41:10,410 --> 00:41:19,330
>> 当我去我的负载平衡器，
看，这是我的负载平衡器，

804
00:41:19,330 --> 00:41:20,945
这里是它的DNS名称。

805
00:41:20,945 --> 00:41:23,410
因此它有为零的实例
服务现在

806
00:41:23,410 --> 00:41:26,040
因为我没有加入
任何情况下它。

807
00:41:26,040 --> 00:41:27,950
所以，我要加我的实例。

808
00:41:27,950 --> 00:41:29,635
因此，这里是我的情况的列表。

809
00:41:29,635 --> 00:41:32,240

810
00:41:32,240 --> 00:41:39,170
所以，如果我想这一个，所以我
去这一个补充。

811
00:41:39,170 --> 00:41:41,150
>> 现在，它要等待
而且它不会

812
00:41:41,150 --> 00:41:43,600
使此实例
直到它变得健康。

813
00:41:43,600 --> 00:41:47,779

814
00:41:47,779 --> 00:41:50,570
而且它不会成为健康
直到我把我的Web服务器上。

815
00:41:50,570 --> 00:41:53,800

816
00:41:53,800 --> 00:41:56,202
所以，让我们，如果我们的RDS来看看
实例备份。

817
00:41:56,202 --> 00:42:03,630

818
00:42:03,630 --> 00:42:04,130
行。

819
00:42:04,130 --> 00:42:04,630
大。

820
00:42:04,630 --> 00:42:06,360
因此，我们的新的RDS实例已准备就绪。

821
00:42:06,360 --> 00:42:08,940
因此，这是终点
我的RDS实例。

822
00:42:08,940 --> 00:42:13,530
所以，我什么都做的是我
要连接到我的RDS实例。

823
00:42:13,530 --> 00:42:17,070
所以，这是现在一个完全
管理MySQL数据库。

824
00:42:17,070 --> 00:42:18,860
它有备份的设置就可以了。

825
00:42:18,860 --> 00:42:20,160
它是多余的。

826
00:42:20,160 --> 00:42:22,030
它在短短几分钟旋转起来。

827
00:42:22,030 --> 00:42:24,870
所以，现在我应该能
SSH进去from--与否SSH，

828
00:42:24,870 --> 00:42:26,690
但登录到它与MySQL客户端。

829
00:42:26,690 --> 00:42:37,602

830
00:42:37,602 --> 00:42:38,120
>> 是的。

831
00:42:38,120 --> 00:42:38,850
所以，我在这里。

832
00:42:38,850 --> 00:42:39,750
我英寸

833
00:42:39,750 --> 00:42:42,680
所以，现在这将是类似的
除了我们只是打破它。

834
00:42:42,680 --> 00:42:45,922
所以，再一次，我要以实际
摆脱这种一秒钟。

835
00:42:45,922 --> 00:42:47,880
好了，我们已经创建
WordPress的数据库

836
00:42:47,880 --> 00:42:50,670
因为我们把WordPress的在那里，所以
我要创建WordPress的用户。

837
00:42:50,670 --> 00:42:52,961
还有的将是一些
这里的细微差别

838
00:42:52,961 --> 00:42:54,237
从我们所做的最后一次。

839
00:42:54,237 --> 00:42:56,070
因此，我们要创建
WordPress的用户，

840
00:42:56,070 --> 00:42:58,200
但现在我们不打算要
从本地主机再登录。

841
00:42:58,200 --> 00:43:00,479
我们将被记录
从EC2实例。

842
00:43:00,479 --> 00:43:03,770
我们不是要一定知道
什么IP地址它是从哪里来的，

843
00:43:03,770 --> 00:43:06,820
或者我们不想指定
它的粒度。

844
00:43:06,820 --> 00:43:09,470
>> 我们将有保障
团体确保只有

845
00:43:09,470 --> 00:43:11,200
我们的网络服务器可以连接到这一点。

846
00:43:11,200 --> 00:43:14,520
所以我只是要允许
它，在这个水平上，

847
00:43:14,520 --> 00:43:16,930
从任何IP地址的连接。

848
00:43:16,930 --> 00:43:17,869
所以，我们只是做了。

849
00:43:17,869 --> 00:43:19,660
现在我们只是
将不得不再次

850
00:43:19,660 --> 00:43:21,701
授予该用户访问权限
WordPress的数据库。

851
00:43:21,701 --> 00:43:24,780

852
00:43:24,780 --> 00:43:30,811
所以，现在我只是要
改变这一张外卡。

853
00:43:30,811 --> 00:43:31,310
行。

854
00:43:31,310 --> 00:43:32,480
因此，我们已经得到了这一点。

855
00:43:32,480 --> 00:43:34,090
让我们在这里了。

856
00:43:34,090 --> 00:43:36,650
所以我们只要确保
我们现在可以登录。

857
00:43:36,650 --> 00:43:39,100
我只是要改变
我的用户名使用WordPress。

858
00:43:39,100 --> 00:43:45,371

859
00:43:45,371 --> 00:43:45,870
行。

860
00:43:45,870 --> 00:43:46,370
所以我们英寸

861
00:43:46,370 --> 00:43:47,607
使作品。

862
00:43:47,607 --> 00:43:50,440
现在我们要去的地方，再说，我有
建立WordPress的这个实例。

863
00:43:50,440 --> 00:43:54,770
因此，我们将有什么
要做的就是去无功，WWW。

864
00:43:54,770 --> 00:43:57,260
我有移动HTML
目录html.old。

865
00:43:57,260 --> 00:44:02,410

866
00:44:02,410 --> 00:44:02,910
行。

867
00:44:02,910 --> 00:44:06,770
并且我们将不得不
下载WordPress的。

868
00:44:06,770 --> 00:44:12,000

869
00:44:12,000 --> 00:44:14,790
>> 行。

870
00:44:14,790 --> 00:44:15,540
提取的WordPress。

871
00:44:15,540 --> 00:44:18,760

872
00:44:18,760 --> 00:44:21,410
我们要移动它
到HTML目录。

873
00:44:21,410 --> 00:44:28,650

874
00:44:28,650 --> 00:44:29,150
行。

875
00:44:29,150 --> 00:44:30,900
我们要去
更改权限。

876
00:44:30,900 --> 00:44:36,021

877
00:44:36,021 --> 00:44:37,562
然后我们要启动Apache。

878
00:44:37,562 --> 00:44:42,490

879
00:44:42,490 --> 00:44:45,820
>> 所以会发生什么
现在有没有是怎么回事

880
00:44:45,820 --> 00:44:49,200
是基本上5
重试这个ELB。

881
00:44:49,200 --> 00:44:53,790
和它的最终，此实例是
要成为健康的ELB。

882
00:44:53,790 --> 00:44:57,871
所以[听不清]在这里。

883
00:44:57,871 --> 00:44:58,370
让我们来看看。

884
00:44:58,370 --> 00:45:00,525
这种情况下是没有健康的。

885
00:45:00,525 --> 00:45:02,400
那么，什么我其实
要做的事情就是我要去

886
00:45:02,400 --> 00:45:05,275
改变健康查了一下
更多的只是一点，使它更快。

887
00:45:05,275 --> 00:45:07,320
我们以后可以改回来。

888
00:45:07,320 --> 00:45:12,561
因此，让我们说，我想健康
门槛3，而不是五。

889
00:45:12,561 --> 00:45:13,060
好不好。

890
00:45:13,060 --> 00:45:15,340
所以，现在我们在服务。

891
00:45:15,340 --> 00:45:17,400
>> 所以，现在我要去
此负载平衡器。

892
00:45:17,400 --> 00:45:19,895
它应该代理我回来
通过对这种情况下，

893
00:45:19,895 --> 00:45:23,195
我们将建立WordPress的就在这里。

894
00:45:23,195 --> 00:45:25,320
现在，如果你有自己的
域名什么的，

895
00:45:25,320 --> 00:45:28,740
你可以做一个CNAME
记录该DNS名称。

896
00:45:28,740 --> 00:45:31,850
和弹性的负载平衡
服务是可伸缩的上后端，

897
00:45:31,850 --> 00:45:34,065
所以它扩展上下对自己的。

898
00:45:34,065 --> 00:45:35,710
因此它可能是多个IP地址。

899
00:45:35,710 --> 00:45:36,584
该IP地址可能会改变。

900
00:45:36,584 --> 00:45:39,063
所以，你应该始终引用
它的DNS名称。

901
00:45:39,063 --> 00:45:41,841

902
00:45:41,841 --> 00:45:42,770
>> 行。

903
00:45:42,770 --> 00:45:43,560
所以在这里我们去。

904
00:45:43,560 --> 00:45:45,215
我们回到我们的设置画面。

905
00:45:45,215 --> 00:45:47,870
现在，我们要做的
同样的过程差不多。

906
00:45:47,870 --> 00:45:49,835
因此，我们的数据库名是WordPress的。

907
00:45:49,835 --> 00:45:52,940
我们的用户名的名字是WordPress的。

908
00:45:52,940 --> 00:45:55,560
我们已经得到了相同的超
安全的密码和以前一样，

909
00:45:55,560 --> 00:45:59,020
除了数据库主机现在
将成为RDS实例。

910
00:45:59,020 --> 00:46:01,222
>> 所以我们要去这里。

911
00:46:01,222 --> 00:46:04,760
我们要去RDS。

912
00:46:04,760 --> 00:46:06,320
我们将去我的实例。

913
00:46:06,320 --> 00:46:07,730
我在这里需要我的终点名称。

914
00:46:07,730 --> 00:46:09,160
这是这一个。

915
00:46:09,160 --> 00:46:10,984
所以我只是要
复制并粘贴此。

916
00:46:10,984 --> 00:46:17,500

917
00:46:17,500 --> 00:46:18,000
行？

918
00:46:18,000 --> 00:46:20,100
让我们看看是否奏效。

919
00:46:20,100 --> 00:46:20,600
行。

920
00:46:20,600 --> 00:46:21,380
使作品。

921
00:46:21,380 --> 00:46:23,530
所以，你可以连接到RDS实例。

922
00:46:23,530 --> 00:46:27,200
再次，它会
是狮子座的真棒博客。

923
00:46:27,200 --> 00:46:39,590

924
00:46:39,590 --> 00:46:40,090
行。

925
00:46:40,090 --> 00:46:42,750
>> 所以，现在我们要
安装我们的WordPress。

926
00:46:42,750 --> 00:46:44,550
所以，我们就大功告成了。

927
00:46:44,550 --> 00:46:46,736
所以让我只要登录
以确保它的工作。

928
00:46:46,736 --> 00:46:51,696

929
00:46:51,696 --> 00:46:54,020
好不好。

930
00:46:54,020 --> 00:46:56,400
>> 所以，现在我们已经有了一个
完全运行WordPress的。

931
00:46:56,400 --> 00:46:58,890
我们可以做的就可以了各种操作。

932
00:46:58,890 --> 00:47:02,210
所以，现在的差别是，
我们有一个单独的数据库。

933
00:47:02,210 --> 00:47:03,470
该数据库是多余的。

934
00:47:03,470 --> 00:47:05,690
我们仍然只有一个网页
服务器，但是我们现在可以

935
00:47:05,690 --> 00:47:08,680
利用这个网页的图像
服务器，再次启动它，

936
00:47:08,680 --> 00:47:11,720
然后我们有两个Web服务器
这背后的负载平衡器。

937
00:47:11,720 --> 00:47:15,894
>> 端点不会改变是否
它的一个或两个，或50的网络服务器。

938
00:47:15,894 --> 00:47:17,060
我们可以扩展它不止于此。

939
00:47:17,060 --> 00:47:21,190
因此，有插件的WordPress的地方
你可以使用S3的静态资产。

940
00:47:21,190 --> 00:47:23,900
您可以使用CloudFront的
缓存这些资产。

941
00:47:23,900 --> 00:47:26,970
您可以使用ElastiCache所以你
可以使用Memcached的基本

942
00:47:26,970 --> 00:47:30,110
存储会话状态存在。

943
00:47:30,110 --> 00:47:32,654
>> 所以，当你从规模
一至多个实例，

944
00:47:32,654 --> 00:47:35,070
你要假设
这些情况是短暂的，

945
00:47:35,070 --> 00:47:36,360
这样他们就可以走了。

946
00:47:36,360 --> 00:47:38,880
所以，你得想
关于我在哪里存储日志，

947
00:47:38,880 --> 00:47:40,290
我在哪里存储会话状态。

948
00:47:40,290 --> 00:47:43,580
我如何使它所以它是OK的
这些实例可以消失，或者更

949
00:47:43,580 --> 00:47:45,010
它们可以出现？

950
00:47:45,010 --> 00:47:47,260
所以，你将不得不
回答这样的问题。

951
00:47:47,260 --> 00:47:48,551
但它是相当常见的模式。

952
00:47:48,551 --> 00:47:52,720
所以，你刚开始卸载任何
执着的东西到其他层。

953
00:47:52,720 --> 00:47:55,380
>> 所以，现在我们已经有了这一点，我们
做[？三层？]的事。

954
00:47:55,380 --> 00:47:57,140
过去的事情我
打算做的，是我

955
00:47:57,140 --> 00:47:59,390
打算让我的负载平衡器
更坚实的一点点

956
00:47:59,390 --> 00:48:02,210
现在，它的标记为健康。

957
00:48:02,210 --> 00:48:06,010
因此，它通常不是一个
为网站好主意

958
00:48:06,010 --> 00:48:10,139
做TCP健康检查，因为
你的Apache可能要涨，

959
00:48:10,139 --> 00:48:11,680
但它可能是在返回PHP错误。

960
00:48:11,680 --> 00:48:12,940
所以你不希望出现这种情况。

961
00:48:12,940 --> 00:48:14,648
>> 那么，什么我要
这里做的是我要去

962
00:48:14,648 --> 00:48:18,230
要改变这种一个HTTP健康检查。

963
00:48:18,230 --> 00:48:22,880
它的将是
index.php文件，而不是index.html的。

964
00:48:22,880 --> 00:48:26,470
而且我们要改变这种
健康的阈值回至五年。

965
00:48:26,470 --> 00:48:27,880
所以这样做了。

966
00:48:27,880 --> 00:48:29,500
所以这仍然应该是健康的。

967
00:48:29,500 --> 00:48:30,000
是的。

968
00:48:30,000 --> 00:48:31,990
因此，我们仍然在服务。

969
00:48:31,990 --> 00:48:36,370
>> 所以这就是你如何设置
WordPress的上升对AWS。

970
00:48:36,370 --> 00:48:41,660
所以我觉得在不到20分钟，我们已经
两者上设置一个实例，就其本身而言，

971
00:48:41,660 --> 00:48:47,302
和一个完整的三层结构，其中
每一层独立地可扩展性。

972
00:48:47,302 --> 00:48:49,010
你可以做各种
有趣的东西

973
00:48:49,010 --> 00:48:51,120
与数据库扩展为好。

974
00:48:51,120 --> 00:48:54,200
>> 让我告诉你一次
这里有趣的事情。

975
00:48:54,200 --> 00:48:59,590
所以我们可以说为了这个，我想
打出来的读取写操作。

976
00:48:59,590 --> 00:49:02,020
我可以创建一个读副本。

977
00:49:02,020 --> 00:49:05,040
所以我打算只
创建一个读副本。

978
00:49:05,040 --> 00:49:11,407
因此，这是要
是wordpressdb1 READ1。

979
00:49:11,407 --> 00:49:13,240
我要做到这一点就
同一区域，但我

980
00:49:13,240 --> 00:49:15,820
能做到这一点在不同的区域。

981
00:49:15,820 --> 00:49:18,740
因此，我们要开始
这里供应读副本。

982
00:49:18,740 --> 00:49:20,390
所以，现在我们正在创建读副本。

983
00:49:20,390 --> 00:49:22,349
这是正在创建
在底部出现。

984
00:49:22,349 --> 00:49:24,140
所以，你可以做各种
这里很酷的东西。

985
00:49:24,140 --> 00:49:25,550
>> 所以我做的演示。

986
00:49:25,550 --> 00:49:27,780
因此，我认为我们有10分钟左右。

987
00:49:27,780 --> 00:49:33,860
所以我会采取任何人的问题
有，任何AWS相关主题。

988
00:49:33,860 --> 00:49:36,980

989
00:49:36,980 --> 00:49:39,395
任何人吗？

990
00:49:39,395 --> 00:49:39,895
酷。

991
00:49:39,895 --> 00:49:40,850
行。

992
00:49:40,850 --> 00:49:42,720
谢谢大家。

993
00:49:42,720 --> 00:49:44,192