1
00:00:03,950 --> 00:00:06,540
В предыдущих уроках

2
00:00:06,540 --> 00:00:10,260
мы видели различные стратегии аутентификации пользователей.

3
00:00:10,260 --> 00:00:12,555
Мы начали с обычной аутентификации,

4
00:00:12,555 --> 00:00:16,500
а затем перешли к файлам cookie и экспресс-сеансам

5
00:00:16,500 --> 00:00:20,805
как способ аутентификации и отслеживания пользователей.

6
00:00:20,805 --> 00:00:24,445
В этом уроке мы рассмотрим Passport,

7
00:00:24,445 --> 00:00:29,450
модуль узла, который делает аутентификацию довольно простой

8
00:00:29,450 --> 00:00:34,880
, ненавязчивой и простой для настройки в вашем приложении.

9
00:00:34,880 --> 00:00:39,125
Passport - это не

10
00:00:39,125 --> 00:00:43,330
что иное, как промежуточное программное обеспечение аутентификации, которое поддерживает различные стратегии, которые могут быть использованы для аутентификации пользователей,

11
00:00:43,330 --> 00:00:47,505
включая локальную стратегию, такую как использование имени пользователя и пароля,

12
00:00:47,505 --> 00:00:54,530
или даже стороннюю аутентификацию или использование OAuth или OAuth 2.0,

13
00:00:54,530 --> 00:00:57,165
например, использование Facebook, Twitter,

14
00:00:57,165 --> 00:01:00,515
или Google+ и так далее.

15
00:01:00,515 --> 00:01:03,600
Мы рассмотрим некоторые детали о Passport,

16
00:01:03,600 --> 00:01:06,995
локальная аутентификация поддерживается Passport.

17
00:01:06,995 --> 00:01:10,520
И в упражнении, которое следует,

18
00:01:10,520 --> 00:01:13,970
мы обновим наше приложение, чтобы использовать

19
00:01:13,970 --> 00:01:19,025
модули Passport и Passport-Local Node для включения.

20
00:01:19,025 --> 00:01:23,700
локальная аутентификация с использованием имени пользователя и пароля.

21
00:01:23,920 --> 00:01:27,670
Итак, как я уже говорил немного ранее,

22
00:01:27,670 --> 00:01:33,185
Passport является очень полезным промежуточным программным обеспечением аутентификации для приложений Node.js.

23
00:01:33,185 --> 00:01:36,675
Это упрощает реализацию аутентификации.

24
00:01:36,675 --> 00:01:39,274
Как мы уже видели в предыдущих упражнениях,

25
00:01:39,274 --> 00:01:45,215
аутентификация включает в себя множество повторяющихся кодов и повторяющихся задач обработки ошибок

26
00:01:45,215 --> 00:01:48,440
и разработки способов проверки

27
00:01:48,440 --> 00:01:52,580
подлинности пользователя, а затем аутентификации пользователя и так далее.

28
00:01:52,580 --> 00:01:56,090
Все это упрощается в Passport с помощью

29
00:01:56,090 --> 00:02:00,040
различных стратегий, которые можно использовать для аутентификации пользователей.

30
00:02:00,040 --> 00:02:04,220
Вы можете использовать локальную стратегию, например, которая основана на

31
00:02:04,220 --> 00:02:09,440
регистрации пользователей в вашей системе с использованием имени пользователя и пароля,

32
00:02:09,440 --> 00:02:14,030
а затем аутентификации их с использованием имени пользователя и пароля.

33
00:02:14,030 --> 00:02:18,965
Passport также поддерживает аутентификацию на основе OpenID

34
00:02:18,965 --> 00:02:22,805
или аутентификацию на основе OAuth или OAuth 2.0,

35
00:02:22,805 --> 00:02:27,135
как поддерживается сторонними аутентификаторами, такими как Facebook

36
00:02:27,135 --> 00:02:29,535
, Twitter, Google+ и так далее.

37
00:02:29,535 --> 00:02:32,465
Мы также можем использовать то, что называется

38
00:02:32,465 --> 00:02:37,880
JSON веб-токенов в качестве другого способа аутентификации, называемого токеном аутентификации.

39
00:02:37,880 --> 00:02:42,485
Мы рассмотрим аутентификацию на основе токенов в более поздней части этого урока.

40
00:02:42,485 --> 00:02:46,465
Кроме того, Passport поддерживает сеансы.

41
00:02:46,465 --> 00:02:51,785
Как мы уже видели в предыдущем упражнении и предыдущем уроке,

42
00:02:51,785 --> 00:02:55,640
экспресс-сеансы — это простой способ отслеживания пользователей

43
00:02:55,640 --> 00:03:01,130
на стороне сервера и обслуживания входящих запросов от клиентов.

44
00:03:01,130 --> 00:03:03,330
Для использования Passport, конечно,

45
00:03:03,330 --> 00:03:05,515
мы установим модуль Passport.

46
00:03:05,515 --> 00:03:08,175
В следующем упражнении мы также

47
00:03:08,175 --> 00:03:11,195
установим модуль Passport-Local для

48
00:03:11,195 --> 00:03:15,060
обеспечения локальной стратегии аутентификации пользователей.

49
00:03:15,060 --> 00:03:19,885
Использование Passport в нашем приложении достаточно просто.

50
00:03:19,885 --> 00:03:23,500
На маршрутах, по которым мы хотим выполнить аутентификацию,

51
00:03:23,500 --> 00:03:27,110
мы просто указываем паспортную аутентификацию, а затем указываем

52
00:03:27,110 --> 00:03:33,320
конкретную стратегию аутентификации, которую мы хотим использовать для аутентификации пользователя.

53
00:03:33,320 --> 00:03:34,810
В качестве примера здесь,

54
00:03:34,810 --> 00:03:36,590
вы видите, что мы применяем

55
00:03:36,590 --> 00:03:41,950
локальную аутентификацию, говоря паспорт аутентифицировать и локально.

56
00:03:41,950 --> 00:03:46,530
И поэтому он использует локальную стратегию для аутентификации пользователей.

57
00:03:46,530 --> 00:03:49,725
Если аутентификация прошла успешно,

58
00:03:49,725 --> 00:03:53,870
то промежуточное программное обеспечение переходит к следующему шагу,

59
00:03:53,870 --> 00:03:57,435
где мы можем дополнительно обработать входящий запрос.

60
00:03:57,435 --> 00:04:03,240
Таким образом, после завершения успешной аутентификации паспорта пользователя,

61
00:04:03,240 --> 00:04:09,300
Passport сам добавляет свойство пользователя в сообщение запроса.

62
00:04:09,300 --> 00:04:15,110
Таким образом, req.user становится доступным для нас с информацией пользователя там,

63
00:04:15,110 --> 00:04:17,960
которую мы можем впоследствии использовать в

64
00:04:17,960 --> 00:04:23,850
нашем экспресс-приложении для обработки запроса, поступающего от конкретных пользователей.

65
00:04:23,850 --> 00:04:30,110
Таким образом, это легко помогает нам определить, какой клиент отправил запрос в

66
00:04:30,110 --> 00:04:32,840
наше приложение и, следовательно

67
00:04:32,840 --> 00:04:37,525
, обслуживать запрос соответствующим образом на основе личности пользователя.

68
00:04:37,525 --> 00:04:40,140
Вместе с Passport мы установим

69
00:04:40,140 --> 00:04:45,225
еще один связанный с паспортом модуль под названием Passport-Local.

70
00:04:45,225 --> 00:04:49,490
Passport-Local поддерживает стратегию,

71
00:04:49,490 --> 00:04:52,190
называемую локальной стратегией аутентификации пользователей

72
00:04:52,190 --> 00:04:55,135
со стандартной комбинацией паролей имени пользователя.

73
00:04:55,135 --> 00:04:58,230
Таким образом, мы настраиваем схему пользователя,

74
00:04:58,230 --> 00:04:59,540
как мы делали раньше,

75
00:04:59,540 --> 00:05:05,030
а затем используем пользовательскую схему или модель для отслеживания имени пользователя

76
00:05:05,030 --> 00:05:11,240
и пароля, а затем Passport-Local зависит от этого, чтобы проверить имя пользователя и пароль.

77
00:05:11,240 --> 00:05:12,815
Итак, чтобы установить его снова,

78
00:05:12,815 --> 00:05:13,985
будучи модулем Node,

79
00:05:13,985 --> 00:05:19,490
мы устанавливаем его с помощью стандартной процедуры установки модуля Passport-Local Node.

80
00:05:19,490 --> 00:05:23,075
После установки модуля Passport-Local Node,

81
00:05:23,075 --> 00:05:30,750
нам нужно указать локальную стратегию и как она фактически используется в Passport.

82
00:05:30,750 --> 00:05:33,465
Итак, чтобы указать локальную стратегию, скажем:

83
00:05:33,465 --> 00:05:39,290
passport.use, и так это позволит нам указать локальную стратегию для использования.

84
00:05:39,290 --> 00:05:42,705
Таким образом, установив Passport-Local,

85
00:05:42,705 --> 00:05:46,900
мы объявим новую локальную стратегию, а затем поставим

86
00:05:46,900 --> 00:05:53,725
соответствующую функцию проверки, которая используется для проверки пользователя.

87
00:05:53,725 --> 00:05:59,585
Если вы используете MongoDB в качестве бэк-энд-магазина, то,

88
00:05:59,585 --> 00:06:02,660
чтобы помочь нам со стратегией Passport-Local,

89
00:06:02,660 --> 00:06:06,045
есть еще один модуль, называемый как Passport-Local Mongoose.

90
00:06:06,045 --> 00:06:10,150
Модуль Passport-Local Mongoose

91
00:06:10,150 --> 00:06:15,290
предоставляет плагин Mongoose, который упростит имя пользователя и пароль входа.

92
00:06:15,290 --> 00:06:19,250
Устанавливая плагин Passport-Local Mongoose, а

93
00:06:19,250 --> 00:06:23,330
затем используя его, когда мы определяем пользовательскую схему

94
00:06:23,330 --> 00:06:29,605
и модель, и тем самым используя поддержку модуля Passport-Local

95
00:06:29,605 --> 00:06:33,995
Mongoose, этот плагин mongoose добавляет в имя пользователя и

96
00:06:33,995 --> 00:06:40,080
зашифрованный способ хранения пароля внутри нашего пользователя модель.

97
00:06:40,080 --> 00:06:43,205
Шифрование выполняется с помощью хэширования

98
00:06:43,205 --> 00:06:47,060
пароля, который мы используем для регистрации пользователей,

99
00:06:47,060 --> 00:06:50,595
а сам хэш использует солевое поле.

100
00:06:50,595 --> 00:06:54,140
Поэтому, если вы знаете что-нибудь о криптографии, в криптографии

101
00:06:54,140 --> 00:06:57,620
соль - это случайная строка, которая используется для выполнения

102
00:06:57,620 --> 00:07:02,135
операции хеширования пароля для хранения.

103
00:07:02,135 --> 00:07:07,590
Таким образом, хэшированный пароль сам фактически хранится в нашей базе данных MongoDB.

104
00:07:07,590 --> 00:07:09,815
Фактический пароль не сохраняется.

105
00:07:09,815 --> 00:07:14,420
Таким образом, когда пользователь пытается аутентифицироваться, используя имя пользователя и пароль,

106
00:07:14,420 --> 00:07:16,820
пароль будет снова хэширован, а затем сравнивать с

107
00:07:16,820 --> 00:07:20,490
хэшированными паролями, хранящимися в нашей базе данных, и

108
00:07:20,490 --> 00:07:28,040
все это предоставляется плагином Mongoose, Passport-Local Mongoose.

109
00:07:28,040 --> 00:07:32,690
Кроме того, Passport-Local Mongoose также добавляет дополнительные методы, которые

110
00:07:32,690 --> 00:07:37,535
очень полезны для настройки стратегии Passport-Local.

111
00:07:37,535 --> 00:07:43,095
Таким образом, в нашем приложении, когда мы определяем пользовательскую схему и модель,

112
00:07:43,095 --> 00:07:46,030
мы импортируем Passport-Local Mongoose, а затем добавим

113
00:07:46,030 --> 00:07:49,495
в качестве плагина для пользовательской схемы.

114
00:07:49,495 --> 00:07:53,000
Этот модуль Passport-Local Mongoose автоматически,

115
00:07:53,000 --> 00:07:56,240
как я сказал, добавляет поле имени пользователя,

116
00:07:56,240 --> 00:08:03,690
а также хешированное поле хранения пароля, используя значение соли, которое он использует для хеширования,

117
00:08:03,690 --> 00:08:08,240
а также предоставляет дополнительные методы, которые позволяют

118
00:08:08,240 --> 00:08:13,010
нам настроить нашу стратегию Passport-Local.

119
00:08:13,010 --> 00:08:16,945
Если мы используем модуль Passport-Local Mongoose,

120
00:08:16,945 --> 00:08:19,185
то локальная стратегия,

121
00:08:19,185 --> 00:08:23,990
Passport-Local Mongoose плагин поддерживает на

122
00:08:23,990 --> 00:08:30,020
модели пользователя метод аутентификации, который будет автоматически выполнять аутентификацию.

123
00:08:30,020 --> 00:08:35,195
На предыдущем слайде я показал вам, как мы будем реализовывать местную стратегию.

124
00:08:35,195 --> 00:08:39,690
Теперь это автоматически предоставляется для вас Passport-Local Mongoose,

125
00:08:39,690 --> 00:08:44,285
просто говоря новый localstrategy user.authenticate.

126
00:08:44,285 --> 00:08:50,730
Тогда нам не нужно явно писать код аутентификации для локальной стратегии.

127
00:08:50,730 --> 00:08:55,445
Кроме того, если вы используете сеансы, поддерживаемые Passport

128
00:08:55,445 --> 00:08:58,555
, то для поддержки сеансов

129
00:08:58,555 --> 00:09:02,630
данные пользователя должны быть сериализованы для

130
00:09:02,630 --> 00:09:06,840
хранения с информацией о сеансе на стороне сервера, а затем,

131
00:09:06,840 --> 00:09:08,690
когда запрос поступает,

132
00:09:08,690 --> 00:09:10,140
из идентификатора сеанса,

133
00:09:10,140 --> 00:09:13,940
информация о пользователе необходимо десериализовать, чтобы извлечь

134
00:09:13,940 --> 00:09:20,160
информацию о пользователе из нашей информации о сеансе, которая хранится на стороне сервера.

135
00:09:20,160 --> 00:09:22,145
Теперь эта

136
00:09:22,145 --> 00:09:27,440
операция сериализации и десериализации уже поддерживается Passport-Local Mongoose через

137
00:09:27,440 --> 00:09:29,990
пользователя сериализации и

138
00:09:29,990 --> 00:09:36,480
десериализации пользовательских методов, доступных из плагина Passport-Local Mongoose.

139
00:09:36,480 --> 00:09:38,095
Таким образом, увидев это,

140
00:09:38,095 --> 00:09:42,680
мы теперь увидим в упражнении, как легко настроить

141
00:09:42,680 --> 00:09:48,120
локальную стратегию аутентификации пользователей с помощью

142
00:09:48,120 --> 00:09:54,490
модулей Passport, Passport-Local и Pasport-Local Mongoose Node.