1
00:00:00,000 --> 00:00:04,969
>> [సంగీతాన్ని]

2
00:00:04,969 --> 00:00:06,010
రిక్ HOULIHAN: అన్ని కుడి.

3
00:00:06,010 --> 00:00:06,600
అందరికీ హాయ్.

4
00:00:06,600 --> 00:00:07,670
నా పేరు రిక్ Houlihan ఉంది.

5
00:00:07,670 --> 00:00:10,330
నేను ఒక సీనియర్ ప్రిన్సిపాల్ ఉన్నాను
AWS వద్ద పరిష్కారాలను వాస్తుశిల్పి.

6
00:00:10,330 --> 00:00:14,070
నేను NoSQL దృష్టి మరియు
DynamoDB సాంకేతికతలు.

7
00:00:14,070 --> 00:00:16,930
నేను మాట్లాడటానికి నేడు ఇక్కడ ఉన్నాను
మీరు ఆ గురించి కొద్దిగా.

8
00:00:16,930 --> 00:00:18,970
>> నా నేపథ్యం ఉంది
ప్రధానంగా డేటా పొర లో.

9
00:00:18,970 --> 00:00:21,390
నేను సగం నా అభివృద్ధి ఖర్చు
కెరీర్, డేటాబేస్ రాయడం

10
00:00:21,390 --> 00:00:25,930
డేటా యాక్సెస్, పరిష్కారాలు
వివిధ అనువర్తనాల కోసం.

11
00:00:25,930 --> 00:00:30,000
నేను క్లౌడ్ వాస్తవీకరణ లో ఉన్నాను
20 సంవత్సరాలు.

12
00:00:30,000 --> 00:00:33,460
క్లౌడ్ క్లౌడ్ ఉంది కాబట్టి ముందు,
మేము వినియోగ కంప్యూటింగ్ కాల్ ఉపయోగిస్తారు.

13
00:00:33,460 --> 00:00:37,170
మరియు ఆలోచన, అది వంటిది జరిగినది
PG & E, మీరు ఉపయోగించడానికి ఏమి చెల్లిస్తారు.

14
00:00:37,170 --> 00:00:38,800
ఈ రోజు మనం క్లౌడ్ కాల్.

15
00:00:38,800 --> 00:00:41,239
>> కానీ సంవత్సరాలు, నేను పని చేసిన
కంపెనీల ఒక జంట కోసం

16
00:00:41,239 --> 00:00:42,530
మీరు బహుశా విన్న ఎప్పుడూ చేసిన.

17
00:00:42,530 --> 00:00:47,470
కానీ నేను సాంకేతిక జాబితా సంకలనం చేసిన
ఘనకార్యాలను నేను మీరు చెప్పే ఇష్టం అంచనా.

18
00:00:47,470 --> 00:00:51,620
నేను క్లౌడ్ వ్యవస్థలు ఎనిమిది పేటెంట్లు కలిగి
వాస్తవీకరణ, మైక్రోప్రాసెసర్ రూపకల్పన,

19
00:00:51,620 --> 00:00:54,440
సంక్లిష్ట ఈవెంట్ ప్రాసెసింగ్,
మరియు ఇతర ప్రాంతాలలో అలాగే.

20
00:00:54,440 --> 00:00:58,290
>> ఈ రోజుల్లో కాబట్టి, నేను NoSQL ఎక్కువగా దృష్టి
టెక్నాలజీలు మరియు తదుపరి తరం

21
00:00:58,290 --> 00:00:59,450
డేటాబేస్.

22
00:00:59,450 --> 00:01:03,370
ఆ నేను వెళుతున్నాను ఏమి సాధారణంగా
గురించి మీకు నేడు మాట్లాడటం ఇక్కడ.

23
00:01:03,370 --> 00:01:06,030
కాబట్టి మీరు ఆశించవచ్చు
ఈ కార్యక్రమం నుండి,

24
00:01:06,030 --> 00:01:08,254
మేము ఒక క్లుప్తమైన ద్వారా వెళ్తారో
డేటా ప్రాసెసింగ్ చరిత్ర.

25
00:01:08,254 --> 00:01:10,420
ఇది ఎల్లప్పుడూ ఉపయోగపడిందా వార్తలు
మేము నుండి వచ్చింది ఎక్కడ అర్థం

26
00:01:10,420 --> 00:01:12,400
మేము ఉన్నాము ఎందుకు మరియు మేము ఇక్కడ.

27
00:01:12,400 --> 00:01:15,600
మరియు మేము కొద్దిగా మాట్లాడండి చేస్తాము
NoSQL టెక్నాలజీ గురించి బిట్

28
00:01:15,600 --> 00:01:17,500
ఒక ప్రాథమిక దృష్టికోణంలో.

29
00:01:17,500 --> 00:01:19,870
>> మేము కొన్ని లోకి పొందుతారు
DynamoDB అంతర్గత.

30
00:01:19,870 --> 00:01:24,350
DynamoDB AWS నో రుచి ఉంటుంది.

31
00:01:24,350 --> 00:01:27,340
ఇది పూర్తిగా నిర్వహించేది మరియు
హోస్ట్ NoSQL పరిష్కారం.

32
00:01:27,340 --> 00:01:32,420
మరియు మేము పట్టిక గురించి కొద్దిగా చర్చ చేస్తాము
నిర్మాణం, API లు, డేటా రకాలు, సూచికలు

33
00:01:32,420 --> 00:01:35,177
మరియు అంతర్గత కొన్ని
ఆ DynamoDB టెక్నాలజీ.

34
00:01:35,177 --> 00:01:37,760
మేము రూపకల్పన కొన్ని లోకి పొందుతారు
నమూనాలు మరియు ఉత్తమ విధానాలను.

35
00:01:37,760 --> 00:01:39,968
మేము మీరు ఎలా గురించి మాట్లాడండి చేస్తాము
కొన్ని కోసం ఈ సాంకేతిక పరిజ్ఞానాన్ని ఉపయోగించిన

36
00:01:39,968 --> 00:01:41,430
నేటి అప్లికేషన్లు.

37
00:01:41,430 --> 00:01:44,820
మరియు తర్వాత మేము కొద్దిగా మాట్లాడండి చేస్తాము
పరిణామం లేదా ఆవిర్భావం గురించి

38
00:01:44,820 --> 00:01:48,980
ప్రోగ్రామింగ్ ఒక కొత్త నమూనా యొక్క
అని ఈవెంట్ నడిచే అప్లికేషన్లు

39
00:01:48,980 --> 00:01:51,580
మరియు DynamoDB అలాగే ఆ పోషిస్తుంది ఎలా.

40
00:01:51,580 --> 00:01:54,690
మరియు మేము మీరు కొద్దిగా చెప్పను
ఒక సూచన నిర్మాణం చర్చ

41
00:01:54,690 --> 00:01:59,540
కాబట్టి మేము కొన్ని గురించి మాట్లాడవచ్చు
మార్గాలు మీరు DynamoDB ఉపయోగించవచ్చు.

42
00:01:59,540 --> 00:02:04,116
>> కాబట్టి మొదటి ఈ ఒక ప్రశ్న off--
నేను చాలా ఒక డేటాబేస్ ఏమిటి, వినడానికి.

43
00:02:04,116 --> 00:02:06,240
ప్రజలు చాలా వారు అనుకుంటున్నాను
ఒక డేటాబేస్ ఏమిటి తెలుసు.

44
00:02:06,240 --> 00:02:08,360
Google మీరు, మీరు ఈ చూస్తారు.

45
00:02:08,360 --> 00:02:11,675
ఇది ఒక నిర్వహించిన డేటా యొక్క నిర్మాణాత్మక సెట్ వార్తలు
ఒక కంప్యూటర్, ముఖ్యంగా ఒక లో

46
00:02:11,675 --> 00:02:13,600
వివిధ మార్గాల్లో అందుబాటులో ఉంది.

47
00:02:13,600 --> 00:02:16,992
నేను ఒక మంచి భావిస్తున్నాను
ఒక ఆధునిక డేటాబేస్ నిర్వచనం.

48
00:02:16,992 --> 00:02:19,450
కానీ నేను ఎందుకంటే అది ఇష్టం లేదు
అది విషయాలను సూచిస్తుంది.

49
00:02:19,450 --> 00:02:20,935
ఇది నిర్మాణం సూచిస్తుంది.

50
00:02:20,935 --> 00:02:23,120
మరియు అది ఒక కంప్యూటర్లో ఉన్న సూచిస్తుంది.

51
00:02:23,120 --> 00:02:25,750
మరియు డేటాబేస్ల జరగలేదు
కంప్యూటర్లలో ఎల్లప్పుడూ ఉనికిలో.

52
00:02:25,750 --> 00:02:28,020
డేటాబేస్లు నిజానికి ఎన్నో విధాలుగా ఉనికిలో.

53
00:02:28,020 --> 00:02:32,000
>> ఒక సో మరింత నిర్వచనం
డేటాబేస్ ఈ వంటి ఏదో ఉంది.

54
00:02:32,000 --> 00:02:34,786
ఒక డేటాబేస్ నిర్వహించబడతాయి
నిల్వ, మేనేజింగ్ మంత్రాంగము

55
00:02:34,786 --> 00:02:35,910
మరియు సమాచారం పొందటం.

56
00:02:35,910 --> 00:02:36,868
ఈ About.com నుండి.

57
00:02:36,868 --> 00:02:42,080
కాబట్టి నేను నిజంగా చర్చలు ఎందుకంటే దీన్ని ఇష్టపడుతున్నాను
గురించి ఒక డాటాబేస్ రిపోజిటరీ ఉండటం,

58
00:02:42,080 --> 00:02:44,800
ఒక భాండాగారం
సమాచారం అవసరం లేదు

59
00:02:44,800 --> 00:02:46,780
ఒక కంప్యూటర్ మీద ఉండే ఏదో.

60
00:02:46,780 --> 00:02:49,290
చరిత్రవ్యాప్తంగా, మేము
ఎల్లప్పుడూ కంప్యూటర్లు కలిగి లేరు.

61
00:02:49,290 --> 00:02:52,110
>> ఇప్పుడు, నేను సగటు అడిగితే
ఏది డెవలపర్ నేడు

62
00:02:52,110 --> 00:02:54,770
ఒక డేటాబేస్, నేను పొందడానికి సమాధానం.

63
00:02:54,770 --> 00:02:56,070
ఎక్కడో నేను stuff కర్ర చేయవచ్చు.

64
00:02:56,070 --> 00:02:56,670
కుడి?

65
00:02:56,670 --> 00:02:58,725
మరియు ఇది నిజం.

66
00:02:58,725 --> 00:02:59,600
కానీ అది దురదృష్టకర ఉంది.

67
00:02:59,600 --> 00:03:02,700
డేటాబేస్ నిజంగా ఎందుకంటే
ఆధునిక అనువర్తనం యొక్క పునాది.

68
00:03:02,700 --> 00:03:04,810
ఇది ఫౌండేషన్ వార్తలు
ప్రతి అప్లికేషన్.

69
00:03:04,810 --> 00:03:07,240
మరియు మీరు ఆ నిర్మించడానికి ఎలా
డేటాబేస్, మీరు ఎలా ఏర్పరచుకునే

70
00:03:07,240 --> 00:03:11,750
ఆ డేటా ఎలా ఖరారు అన్నారు
మీరు స్కేల్ వంటి అప్లికేషన్ నిర్వహిస్తుంది.

71
00:03:11,750 --> 00:03:14,640
>> నా ఉద్యోగం నేడు చాలా
వ్యవహరిస్తున్న ఏమి

72
00:03:14,640 --> 00:03:17,180
ఉన్నప్పుడు డెవలపర్లు జరుగుతుంది
ఈ పద్ధతిని

73
00:03:17,180 --> 00:03:19,510
మరియు దాని తరువాత పరిణామాలు వ్యవహరించే
ఒక అప్లికేషన్ ఆ

74
00:03:19,510 --> 00:03:24,966
ఇప్పుడు అసలు దాటి స్కేలింగ్చిన్న
చెడు డిజైన్ నుండి అంగీకార మరియు బాధ.

75
00:03:24,966 --> 00:03:26,840
సో ఆశాజనక ఉన్నప్పుడు మీరు
నేడు దూరంగా నడిచి, మీరు చేస్తాము

76
00:03:26,840 --> 00:03:29,010
టూల్స్ ఒక జంట కలిగి
మీరు ఉంటాం మీ బెల్ట్

77
00:03:29,010 --> 00:03:32,566
ఆ అదే తప్పులు చేయకుండా.

78
00:03:32,566 --> 00:03:33,066
అయితే సరే.

79
00:03:33,066 --> 00:03:36,360
కాబట్టి యొక్క ఒక చిన్న బిట్ గురించి మాట్లాడటానికి వీలు
డేటాబేస్ టెక్నాలజీ యొక్క కాలక్రమణిక.

80
00:03:36,360 --> 00:03:38,830
నేను ఒక చదవడానికి అనుకుంటున్నాను
వ్యాసం కాదు ఆ కాలం క్రితం

81
00:03:38,830 --> 00:03:43,020
మరియు అది లైన్లు ఏదో చెప్పారు
ఇది చాలా కవితా ప్రకటన.

82
00:03:43,020 --> 00:03:46,590
ఇది ఇలా చెప్పాడు చరిత్ర
డేటా ప్రాసెసింగ్ ఉంది

83
00:03:46,590 --> 00:03:49,350
అధిక వాటర్మార్క్ల పూర్తి
డేటా సమృద్ధి.

84
00:03:49,350 --> 00:03:49,920
అలాగే.

85
00:03:49,920 --> 00:03:52,532
ఇప్పుడు, నేను ఆ రకమైన నిజం అంచనా.

86
00:03:52,532 --> 00:03:54,990
కానీ నేను నిజానికి ఉంది చూడండి
చరిత్ర నిజానికి నిండి ఉంటుంది

87
00:03:54,990 --> 00:03:56,820
డేటా ఒత్తిడి అధిక వాటర్మార్క్ తో.

88
00:03:56,820 --> 00:04:00,040
డేటా రేటు ఎందుకంటే
త్రాగుట చెయ్యకపోతే ఎప్పుడూ.

89
00:04:00,040 --> 00:04:01,360
ఇది మాత్రమే పెరుగుతుంది.

90
00:04:01,360 --> 00:04:03,670
>> మరియు ఆవిష్కరణ ఏర్పడుతుంది
మేము డేటా ఒత్తిడి, చూసినట్టుగా

91
00:04:03,670 --> 00:04:07,825
అని మొత్తం సమాచారం
ఇప్పుడు సిస్టమ్ లోకి రాబోయే.

92
00:04:07,825 --> 00:04:12,027
మరియు అది ప్రాసెస్ చేయలేము
సమర్ధవంతంగా సమయంలో లేదా కాస్ట్ గాని.

93
00:04:12,027 --> 00:04:14,110
మేము ప్రారంభించినప్పుడు మరియు ఆ
డేటా ఒత్తిడి చూడండి.

94
00:04:14,110 --> 00:04:15,920
>> కాబట్టి మేము చూస్తున్నప్పుడు
మొదటి డేటాబేస్, ఈ

95
00:04:15,920 --> 00:04:17,180
మా చెవులు మధ్య అని ఒకటి.

96
00:04:17,180 --> 00:04:18,310
మేము అన్ని అది తో పుడితే.

97
00:04:18,310 --> 00:04:19,194
ఇది ఒక nice డేటాబేస్.

98
00:04:19,194 --> 00:04:21,110
ఇది అధిక లభ్యత ఉంది.

99
00:04:21,110 --> 00:04:21,959
ఇది ఎల్లప్పుడూ ఉంది.

100
00:04:21,959 --> 00:04:23,930
మీరు ఎల్లప్పుడూ పొందవచ్చు.

101
00:04:23,930 --> 00:04:24,890
>> కానీ అది ఒకే యూజర్ యొక్క.

102
00:04:24,890 --> 00:04:26,348
నేను మీరు నా ఆలోచనలు భాగస్వామ్యం చెయ్యలేరు.

103
00:04:26,348 --> 00:04:28,370
మీరు నా ఆలోచనలు పొందలేము
మీరు వాటిని కావలసినప్పుడు.

104
00:04:28,370 --> 00:04:30,320
మరియు వారి abilitiy కాబట్టి మంచి కాదు.

105
00:04:30,320 --> 00:04:32,510
మేము విషయాలు మర్చిపోతే.

106
00:04:32,510 --> 00:04:36,540
ప్రతి ఇప్పుడు ఆపై, మాకు ఒకటి ఆకులు
మరియు మరొక ఉనికికి సంచరించును

107
00:04:36,540 --> 00:04:39,110
మరియు మేము ప్రతిదీ కోల్పోతారు
ఆ డేటాబేస్ లో ఉంది.

108
00:04:39,110 --> 00:04:40,640
కాబట్టి అన్ని మంచి కాదు.

109
00:04:40,640 --> 00:04:43,189
>> మరియు ఈ కాలక్రమేణా బాగా పని
మేము రోజు తిరిగి ఉన్నప్పుడు

110
00:04:43,189 --> 00:04:46,230
మేము నిజంగా తెలుసు అవసరమైన అన్ని ఉంది
పేరు మేము రేపు వెళ్ళడానికి వెళ్తున్నారు

111
00:04:46,230 --> 00:04:49,630
లేదా మేము మంచి ఆహారము సేకరించడానికి పేరు.

112
00:04:49,630 --> 00:04:52,820
కానీ మేము ప్రారంభించారు పెరగడం
నాగరికత మరియు ప్రభుత్వం ప్రారంభించారు

113
00:04:52,820 --> 00:04:55,152
అస్తిత్వంలోకి వస్తాయి, మరియు
వ్యాపారాలు, అభివృద్ధి చెందడం ప్రారంభమైంది

114
00:04:55,152 --> 00:04:57,360
మేము గ్రహించడం ప్రారంభించారు
కంటే కొద్దిగా ఎక్కువ అవసరం

115
00:04:57,360 --> 00:04:58,210
మేము మా తల ఉంచారు కాలేదు.

116
00:04:58,210 --> 00:04:58,870
అయితే సరే?

117
00:04:58,870 --> 00:05:00,410
>> ఈ రికార్డ్ వ్యవస్థలు అవసరం.

118
00:05:00,410 --> 00:05:02,220
మేము సామర్థ్యం స్టోర్ డేటా ప్రదేశాలు అవసరమైన.

119
00:05:02,220 --> 00:05:05,450
కాబట్టి మేము, డాక్యుమెంట్లు రాయడం ప్రారంభించారు
లైబ్రరీస్ అండ్ ఆర్కైవ్స్ సృష్టించడం.

120
00:05:05,450 --> 00:05:08,000
మేము ఒక అభివృద్ధి చేయడం ప్రారంభించింది
వ్యవస్థ ఒక లెడ్జర్ అకౌంటింగ్.

121
00:05:08,000 --> 00:05:12,200
మరియు లెడ్జర్ లెక్కింపు ఆ వ్యవస్థ
, చాలా శతాబ్దాల వరకు ప్రపంచవ్యాప్తంగా నడిచింది

122
00:05:12,200 --> 00:05:15,580
ఇంకా సహస్రాబ్దాల వంటి
మేము రకమైన పాయింట్ పెరిగింది

123
00:05:15,580 --> 00:05:18,420
అక్కడ ఆ డేటాను లోడ్ అధిగమించింది
ఆ వ్యవస్థల్లో సామర్థ్యం

124
00:05:18,420 --> 00:05:19,870
ఇది కలిగి చెయ్యలేరు.

125
00:05:19,870 --> 00:05:22,070
>> మరియు ఈ నిజంగా 1880 లో జరిగింది.

126
00:05:22,070 --> 00:05:22,570
కుడి?

127
00:05:22,570 --> 00:05:24,390
1880 US సెన్సస్ లో.

128
00:05:24,390 --> 00:05:26,976
ఈ పేరు రేపే నిజంగా
ఆధునిక డేటా ప్రాసెసింగ్ అభిప్రాయపడుతున్నారు.

129
00:05:26,976 --> 00:05:28,850
ఈ సమయంలో ఉంది
డేటా మొత్తాన్ని

130
00:05:28,850 --> 00:05:32,060
ఆ ద్వారా సేకరించిన కావడంతో
సంయుక్త ప్రభుత్వం పాయింట్ వచ్చింది

131
00:05:32,060 --> 00:05:34,005
పేరు ప్రాసెస్ ఎనిమిది సంవత్సరాలు పట్టింది.

132
00:05:34,005 --> 00:05:36,350
>> ఇప్పుడు, ఎనిమిది years-- వంటి
మీరు జనాభా లెక్కల తెలుసు

133
00:05:36,350 --> 00:05:39,180
పరుగులు ప్రతి 10 years-- కాబట్టి ఇది
అందంగా స్పష్టమైన ఆ సమయానికి మేము

134
00:05:39,180 --> 00:05:41,419
1890 జనాభా లెక్కల వచ్చింది
డేటా మొత్తం ఆ

135
00:05:41,419 --> 00:05:43,210
ప్రాసెస్ కానుంది
ప్రభుత్వం ఉంది

136
00:05:43,210 --> 00:05:46,335
10 సంవత్సరాల అధిగమించటానికి వెళుతున్న ఆ
ప్రారంభించింది కొత్త జనాభా లెక్కల పడుతుందని.

137
00:05:46,335 --> 00:05:47,250
ఈ సమస్య ఏర్పడింది.

138
00:05:47,250 --> 00:05:49,000
>> కాబట్టి ఒక వ్యక్తి హెర్మన్ అనే
హోలెరిత్ పాటు వచ్చింది

139
00:05:49,000 --> 00:05:52,640
మరియు అతను యూనిట్ రికార్డు పంచ్ కనుగొన్నారు
కార్డులు, పంచ్ కార్డ్ రీడర్, పంచ్ కార్డు

140
00:05:52,640 --> 00:05:58,420
పట్టిక తయారుచేయు, మరియు సమాకలనం యొక్క
ఈ సాంకేతిక విధానాల.

141
00:05:58,420 --> 00:06:01,860
అతడు ఏర్పడిన ఆ సంస్థ
సమయం, ఇతరుల ఒక జంట కలిసి,

142
00:06:01,860 --> 00:06:05,450
నిజానికి అయ్యింది యొక్క ఒకానొక
ఇవాళ మనకు తెలిసినవి చిన్న కంపెనీ IBM అని.

143
00:06:05,450 --> 00:06:08,417
>> కాబట్టి IBM నిజానికి ఉంది
డేటాబేస్ వ్యాపార.

144
00:06:08,417 --> 00:06:09,750
మరియు ఆ వాళ్ళు ఏమి నిజంగా ఉంది.

145
00:06:09,750 --> 00:06:11,110
వారు డేటా ప్రాసెసింగ్ చేశాడు.

146
00:06:11,110 --> 00:06:15,400
>> పంచ్ వ్యాప్తితో కాబట్టి
కార్డులు, ఒక తెలివిగల విధానాల

147
00:06:15,400 --> 00:06:18,560
ఆ పరపతి సామర్థ్యం
టెక్నాలజీ క్రమబద్ధీకరించబడతాయి ఫలితంగా సెట్లు పోల్కు.

148
00:06:18,560 --> 00:06:20,726
మీరు ఈ చిత్రంలో చూడవచ్చు
అక్కడ మేము కొద్దిగా కలిగి

149
00:06:20,726 --> 00:06:23,970
అది కొద్దిగా small-- కానీ మీరు చూడగలరు
చాలా తెలివిగల యాంత్రిక విధానం

150
00:06:23,970 --> 00:06:26,970
మేము ఒక పంచ్ కార్డు డెక్ కలిగి ఉన్న.

151
00:06:26,970 --> 00:06:28,720
ఎవరో తీసుకోవడం
కొద్దిగా screwdriver

152
00:06:28,720 --> 00:06:31,400
మరియు ద్వారా అంటుకునే
విభాగాలు మరియు అది అప్ లిఫ్టింగ్

153
00:06:31,400 --> 00:06:34,820
ఆ మ్యాచ్లో పొందడానికి ఆ
వేరుచేయబడిన ఫలితాలను సెట్.

154
00:06:34,820 --> 00:06:36,270
>> ఈ ఒక సముదాయంగా ఉంటుంది.

155
00:06:36,270 --> 00:06:38,690
మేము ఈ అన్ని మీకు
కంప్యూటర్ లో నేడు

156
00:06:38,690 --> 00:06:40,100
మీరు డేటాబేస్ లో దాన్ని పేరు.

157
00:06:40,100 --> 00:06:41,620
మేము కుడి, మానవీయంగా దీన్ని ఉపయోగిస్తారు?

158
00:06:41,620 --> 00:06:42,994
ప్రజలు కలిసి ఈ విషయాలు చాలు.

159
00:06:42,994 --> 00:06:45,440
మరియు అది వ్యాప్తితో ఉంది
ఈ పంచ్ కార్డులు

160
00:06:45,440 --> 00:06:50,070
మేము పిలిచారు డేటా డ్రమ్స్ లోకి
మరియు డేటా రీల్స్, కాగితం టేప్.

161
00:06:50,070 --> 00:06:55,980
>> డేటా ప్రాసెసింగ్ పరిశ్రమ పట్టింది
క్రీడాకారుడు పియానోలు నుండి ఒక పాఠం.

162
00:06:55,980 --> 00:06:57,855
ప్లేయర్ తిరిగి పియానోలు
శతాబ్దపు మలుపు

163
00:06:57,855 --> 00:07:02,100
విభాగాలు తో కాగితం రీల్స్ ఉపయోగించారు
మీద ప్లే కీలను చెప్పడం.

164
00:07:02,100 --> 00:07:05,380
ఆ సాంకేతికతను ఉపయోగించుకున్నాడు కాబట్టి
చివరికి, డిజిటల్ డేటాను నిల్వ

165
00:07:05,380 --> 00:07:08,070
వారు ఆ డేటా చాలు కాలేదు ఎందుకంటే
ఆ కాగితం టేప్ రీల్స్ అంటిస్తుంది.

166
00:07:08,070 --> 00:07:10,870
>> ఇప్పుడు, ఫలితంగా, డేటా
ఎలా నిజానికి జరిగినది

167
00:07:10,870 --> 00:07:14,960
మీరు ఈ డేటాను నేరుగా యాక్సెస్
మీరు నిల్వ ఎలా ఆధారపడి.

168
00:07:14,960 --> 00:07:17,825
నేను ఒక టేప్ డేటా ఉంచితే,
నేను సరళంగా డేటా యాక్సెస్ వచ్చింది.

169
00:07:17,825 --> 00:07:20,475
నేను మొత్తం రోల్ వచ్చింది
టేప్ అన్ని డేటా యాక్సెస్.

170
00:07:20,475 --> 00:07:22,600
నేను పంచ్ డేటా ఉంచితే
కార్డులు, నేను ప్రాప్తి చేయగల

171
00:07:22,600 --> 00:07:26,270
కొంచెం యాదృచ్ఛిక లో
ఫ్యాషన్, బహుశా కాదు త్వరగా.

172
00:07:26,270 --> 00:07:30,770
>> కానీ ఎలా పరిమితులలో ఉన్నాయి మేము
నిల్వ ఎలా ఆధారంగా డేటా యాక్సెస్.

173
00:07:30,770 --> 00:07:32,890
కాబట్టి ఈ సమస్య ఏర్పడింది
'50 వెళ్లడానికి.

174
00:07:32,890 --> 00:07:37,890
మళ్ళీ, మేము ఆ చూడడానికి చేయవచ్చు
ప్రాసెస్ కొత్త సాంకేతికతను అభివృద్ధి

175
00:07:37,890 --> 00:07:41,670
డేటా, కుడి, అది తెరుచుకోవడంతో
కొత్త పరిష్కారాలను కోసం తలుపు

176
00:07:41,670 --> 00:07:45,852
కొత్త ప్రోగ్రామ్ల కోసం, కొత్త
డేటా కోసం అప్లికేషన్లు.

177
00:07:45,852 --> 00:07:47,810
మరియు నిజంగా, పాలన
కారణం కావచ్చు

178
00:07:47,810 --> 00:07:49,435
ఎందుకు మేము ఈ వ్యవస్థల్లో కొన్నింటిని అభివృద్ధి.

179
00:07:49,435 --> 00:07:52,290
కానీ వ్యాపార వేగంగా మారింది
పరిణామం వెనుక డ్రైవర్

180
00:07:52,290 --> 00:07:54,720
ఆధునిక డేటాబేస్ మరియు
ఆధునిక ఫైల్ సిస్టమ్.

181
00:07:54,720 --> 00:07:56,870
>> తదుపరి విషయం కాబట్టి
'50 లో వచ్చింది

182
00:07:56,870 --> 00:08:00,780
దస్త్ర వ్యవస్థ మరియు ఉంది
రాండమ్ యాక్సెస్ నిల్వ అభివృద్ధి.

183
00:08:00,780 --> 00:08:02,050
ఈ అందమైన ఉంది.

184
00:08:02,050 --> 00:08:06,230
ఇప్పుడు, అకస్మాత్తుగా, మేము ఉంచవచ్చు మా
ఈ హార్డ్ డ్రైవ్లు ఎక్కడైనా ఫైళ్లు

185
00:08:06,230 --> 00:08:09,760
మరియు మనం యాదృచ్చికంగా ఈ డేటాను ప్రాప్తి చేయవచ్చు.

186
00:08:09,760 --> 00:08:11,950
మేము ఆ అన్వయించడం చేయవచ్చు
ఫైళ్లు నుండి సమాచారాన్ని.

187
00:08:11,950 --> 00:08:14,920
మరియు మేము ప్రపంచంలోని అన్ని పరిష్కరించాడు
డేటా ప్రాసెసింగ్ సమస్యలు.

188
00:08:14,920 --> 00:08:17,550
>> మరియు ఆ కొనసాగింది గురించి 20 లేదా
పరిణామం వరకు 30 సంవత్సరాల

189
00:08:17,550 --> 00:08:22,100
రిలేషనల్ డేటాబేస్, ఏ
ప్రపంచ ఇప్పుడు మేము నిర్ణయించుకుంది ఉన్నప్పుడు

190
00:08:22,100 --> 00:08:27,940
ఓడిస్తాడు ఒక రిపోజిటరీ కలిగి ఉండాలి
ఫైల్ అంతటా డేటా విస్తరణను

191
00:08:27,940 --> 00:08:29,540
సృషించిన వ్యవస్థలు. కుడి?

192
00:08:29,540 --> 00:08:34,270
చాలా పంపిణీ చాలా డేటాను
స్థలాలు, డేటా యొక్క డి-నకలు,

193
00:08:34,270 --> 00:08:37,120
మరియు నిల్వ ఖర్చు అపరిమితంగా ఉంది.

194
00:08:37,120 --> 00:08:43,760
>> '70 లో, అత్యంత ఖరీదైన వనరు
ఒక కంప్యూటర్ ఉందని నిల్వ ఉంది.

195
00:08:43,760 --> 00:08:46,200
ప్రాసెసర్ ఉంది
ఒక స్థిర వ్యయం వంటి చూచుటకు.

196
00:08:46,200 --> 00:08:49,030
నేను బాక్స్ కొనుగోలు చేసినప్పుడు,
CPU కొంత పని చేస్తుంది.

197
00:08:49,030 --> 00:08:51,960
ఇది లేదో స్పిన్నింగ్ చేస్తాడు
ఇది నిజానికి పని లేదా కాదు.

198
00:08:51,960 --> 00:08:53,350
నిజంగా ఒక మునిగిపోయాయి ధర ఉంది.

199
00:08:53,350 --> 00:08:56,030
>> కాని ఒక వంటి నాకు ఖర్చు
వ్యాపార నిల్వ ఉంది.

200
00:08:56,030 --> 00:09:00,020
నేను తదుపరి మరింత డిస్కులు కొనుగోలు కలిగి ఉంటే
నెల, నేను చెల్లించాలని నిజమైన ఖర్చు వార్తలు.

201
00:09:00,020 --> 00:09:01,620
మరియు ఆ నిల్వ ఖరీదైనది.

202
00:09:01,620 --> 00:09:05,020
>> ఇప్పుడు మేము ఫాస్ట్ ఫార్వార్డ్ 40 సంవత్సరాల
మరియు మేము వేరే సమస్య.

203
00:09:05,020 --> 00:09:10,020
గణన ఇప్పుడు
అత్యంత ఖరీదైన వనరు.

204
00:09:10,020 --> 00:09:11,470
నిల్వ చవకగా.

205
00:09:11,470 --> 00:09:14,570
మనం ఎక్కడైనా వెళ్ళే ఉద్దేశ్యం
క్లౌడ్ మరియు మేము చౌకగా నిల్వ వెదుక్కోవచ్చు.

206
00:09:14,570 --> 00:09:17,190
కానీ నేను దొరకదు చౌకగా గణన ఉంది.

207
00:09:17,190 --> 00:09:20,700
>> నేటి పరిణామం కాబట్టి
సాంకేతిక, డేటాబేస్ టెక్నాలజీ,

208
00:09:20,700 --> 00:09:23,050
నిజంగా దృష్టి కేంద్రీకరించింది
పంపిణీ డేటాబేస్

209
00:09:23,050 --> 00:09:26,960
ఆ బాధపడుతున్నారు లేదు
స్థాయి అదే రకం

210
00:09:26,960 --> 00:09:29,240
సంబంధిత డేటాబేస్లను పరిమితులు.

211
00:09:29,240 --> 00:09:32,080
మేము గురించి కొద్దిగా చర్చ చేస్తాము
ఆ నిజంగా అర్థం ఏమిటి.

212
00:09:32,080 --> 00:09:34,760
>> కానీ కారణాలలో ఒకటి మరియు
దీన్ని మేము వెనుక డ్రైవర్

213
00:09:34,760 --> 00:09:38,290
డేటా ఒత్తిడి గురించి మాట్లాడారు.

214
00:09:38,290 --> 00:09:41,920
డేటా ఒత్తిడి ఏదో ఉంది
ఆవిష్కరణ నడుపుతుంది.

215
00:09:41,920 --> 00:09:44,610
మరియు మీరు వద్ద చూస్తే
గత ఐదు సంవత్సరాల,

216
00:09:44,610 --> 00:09:48,180
ఈ ఏమి డేటా యొక్క ఒక చార్ట్ ఉంది
సాధారణ సంస్థలో లోడ్

217
00:09:48,180 --> 00:09:49,640
గత ఐదు సంవత్సరాలలో కనిపిస్తోంది.

218
00:09:49,640 --> 00:09:52,570
>> మరియు thumb సాధారణ నియమం
ఈ days-- మీరు Google-- వెళ్ళి ఉంటే

219
00:09:52,570 --> 00:09:55,290
డేటా 90% అని
మేము నేడు నిల్వ, మరియు అది

220
00:09:55,290 --> 00:09:57,330
గత రెండు సంవత్సరాల లోపల ఉత్పత్తి.

221
00:09:57,330 --> 00:09:57,911
అలాగే.

222
00:09:57,911 --> 00:09:59,410
ఇప్పుడు, ఈ కొత్త అని ధోరణి కాదు.

223
00:09:59,410 --> 00:10:01,230
ఈ కూడా ఒక ధోరణి ఉంది
100 సంవత్సరాల కోసం బయటకు వెళ్లి.

224
00:10:01,230 --> 00:10:03,438
ఎవర్ హెర్మన్ హోలెరిత్ నుండి
పంచ్ కార్డు అభివృద్ధి,

225
00:10:03,438 --> 00:10:08,040
మేము డేటా రిపోజిటరీలను నిర్మాణ పరిష్కరించగలుగుతున్నాము
మరియు అసాధారణ రేట్లు వద్ద డేటా సేకరించడం.

226
00:10:08,040 --> 00:10:10,570
>> గత 100 సంవత్సరాలుగా,
మేము ఈ ధోరణి చూసిన.

227
00:10:10,570 --> 00:10:11,940
ఆ మార్చడానికి మాత్రం కాదు.

228
00:10:11,940 --> 00:10:14,789
ముందుకు వెళుతున్న, మేము చూడండి చూడాలని
ఈ కాకపోయినా ఒక వేగవంతమైన ధోరణి.

229
00:10:14,789 --> 00:10:16,330
మరియు మీరు ఆ కనిపిస్తుంది ఏమి చూడగలరు.

230
00:10:16,330 --> 00:10:23,510
>> 2010 లో ఒక వ్యాపార ఒక కలిగి ఉంటే
నిర్వహణ కింద డేటా టెరాబైట్,

231
00:10:23,510 --> 00:10:27,080
వారు ఉన్నారని అర్ధం నేడు
డేటా 6.5 petabytes మేనేజింగ్.

232
00:10:27,080 --> 00:10:30,380
ఆ 6,500 రెట్లు ఎక్కువ డేటా ఉంది.

233
00:10:30,380 --> 00:10:31,200
నేను ఈ తెలుసు.

234
00:10:31,200 --> 00:10:33,292
నేను ప్రతి రోజు ఈ వ్యాపారాలు పని.

235
00:10:33,292 --> 00:10:35,000
ఐదు సంవత్సరాల క్రితం, నేను
కంపెనీలకు మాట్లాడిన

236
00:10:35,000 --> 00:10:38,260
ఏమి ఒక నొప్పి గురించి నాకు ఎవరు మాట్లాడిన
అది డేటా టెరాబైట్ల నిర్వహించడానికి ఉంది.

237
00:10:38,260 --> 00:10:39,700
మరియు వారు మాట్లాడిన
మేము చూడండి ఎలా గురించి నాకు

238
00:10:39,700 --> 00:10:41,825
ఈ బహుశా అన్నారు
ఒక petabyte లేదా రెండు ఉండాలి

239
00:10:41,825 --> 00:10:43,030
సంవత్సరాల జంట లోపల.

240
00:10:43,030 --> 00:10:45,170
>> ఈ అదే కంపెనీలు
నేను సమావేశం వెబ్ నేడు,

241
00:10:45,170 --> 00:10:48,100
మరియు వారు గురించి నాకు మాట్లాడటం చేస్తున్నాం
సమస్య మేనేజింగ్ అక్కడ కలిగి ఉంటాయి

242
00:10:48,100 --> 00:10:51,440
పదుల, డేటా యొక్క 20 petabytes.

243
00:10:51,440 --> 00:10:53,590
యొక్క పేలుడు కాబట్టి
పరిశ్రమలో డేటా

244
00:10:53,590 --> 00:10:56,670
అపారమైన డ్రైవింగ్ ఉంది
మంచి పరిష్కారాల కోసం అవసరం.

245
00:10:56,670 --> 00:11:00,980
మరియు రిలేషనల్ డేటాబేస్
కేవలం డిమాండ్ వరకు నివసిస్తున్న లేదు.

246
00:11:00,980 --> 00:11:03,490
>> కాబట్టి ఒక సరళ ఉంది
డేటా ఒత్తిడి మధ్య సహసంబంధాన్ని

247
00:11:03,490 --> 00:11:05,210
మరియు సాంకేతిక ఆవిష్కరణ.

248
00:11:05,210 --> 00:11:07,780
చరిత్ర మాకు చూపించింది
ఈ కాలక్రమేణా,

249
00:11:07,780 --> 00:11:11,090
చేసినప్పుడు డేటా పరిమాణం
ఆ ప్రాసెస్ అవసరం

250
00:11:11,090 --> 00:11:15,490
వ్యవస్థ సామర్థ్యాన్ని దాటిపోతుంది
ఒక సహేతుకమైన సమయం లో ప్రాసెస్

251
00:11:15,490 --> 00:11:18,870
లేదా ఒక సహేతుకమైన ధర వద్ద,
అప్పుడు కొత్త టెక్నాలజీ

252
00:11:18,870 --> 00:11:21,080
ఆ సమస్యలను పరిష్కరించటానికి కనుగొన్నారు ఉంటాయి.

253
00:11:21,080 --> 00:11:24,090
ఆ కొత్త టెక్నాలజీ,
క్రమంగా, తలుపు తెరవడానికి

254
00:11:24,090 --> 00:11:27,840
సమస్యలు వేరే జత ఇది
మరింత డేటా సమకూరుస్తున్నాడు.

255
00:11:27,840 --> 00:11:29,520
>> ఇప్పుడు, మేము ఈ ఆపడానికి వెళ్ళడం లేదు చేస్తున్నాం.

256
00:11:29,520 --> 00:11:30,020
కుడి?

257
00:11:30,020 --> 00:11:31,228
మేము ఈ ఆపడానికి వెళ్ళడం లేదు చేస్తున్నాం.

258
00:11:31,228 --> 00:11:31,830
ఎందుకు?

259
00:11:31,830 --> 00:11:35,520
మీరు ప్రతిదీ తెలియదు ఎందుకంటే
విశ్వంలో తెలుసుకోవటానికి ఉంది.

260
00:11:35,520 --> 00:11:40,510
మరియు కాలం మేము సజీవంగా పరిష్కరించగలుగుతున్నాము
మనిషి యొక్క చరిత్ర అంతటా,

261
00:11:40,510 --> 00:11:43,440
మేము ఎల్లప్పుడూ మరింత తెలుసుకోవాలంటే నిర్వహిస్తాయి.

262
00:11:43,440 --> 00:11:49,840
>> కాబట్టి అది మేము తరలించడానికి ప్రతి అంగుళం వంటి తెలుస్తోంది
సైంటిఫిక్ డిస్కవరీ యొక్క మార్గం డౌన్,

263
00:11:49,840 --> 00:11:54,620
మేము డేటా మొత్తం గుణించడం ఉంటాయి
మేము విశేషంగా ప్రాసెస్ అవసరం

264
00:11:54,620 --> 00:11:59,920
మేము మరింత మరియు మరింత వెలికితీసే విధంగా
జీవితం యొక్క అంతర్గత పనితీరుల గురించి

265
00:11:59,920 --> 00:12:04,530
, విశ్వం ఎలా పనిచేస్తుంది గురించి
సైంటిఫిక్ డిస్కవరీ డ్రైవింగ్,

266
00:12:04,530 --> 00:12:06,440
మరియు ఆవిష్కరణ ఆ
మేము నేడు చేయుచున్నారు.

267
00:12:06,440 --> 00:12:09,570
డేటా పరిమాణం కేవలం
నిరంతరం పెరుగుతుంది.

268
00:12:09,570 --> 00:12:12,120
కాబట్టి వ్యవహరించే సామర్థ్యం
ఈ సమస్య అపారమైన ఉంది.

269
00:12:12,120 --> 00:12:14,790

270
00:12:14,790 --> 00:12:17,410
>> విషయాలు ఒకటి కాబట్టి
మేము NoSQL ఎందుకు కనిపిస్తుంది?

271
00:12:17,410 --> 00:12:19,200
ఎలా NoSQL ఈ సమస్యను పరిష్కరించడానికి లేదు?

272
00:12:19,200 --> 00:12:24,980
Well, రిలేషనల్ డేటాబేస్,
నిర్మితీకృత ప్రశ్నా భాష,

273
00:12:24,980 --> 00:12:28,600
SQL-- నిజంగా నిర్మాణం వార్తలు
రిలేషనల్ ఈ విషయాలు డేటాబేస్

274
00:12:28,600 --> 00:12:30,770
నిల్వ కోసం ఆప్టిమైజ్.

275
00:12:30,770 --> 00:12:33,180
>> తిరిగి '70 లో, మళ్ళీ,
డిస్క్ ఖరీదైనది.

276
00:12:33,180 --> 00:12:36,990
నిల్వ ప్రొవిజనింగ్ వ్యాయామం
సంస్థలో ఎప్పటికీ ముగింపు ఉంది.

277
00:12:36,990 --> 00:12:37,490
నాకు తెలుసు.

278
00:12:37,490 --> 00:12:38,020
నేను నివసించారు.

279
00:12:38,020 --> 00:12:41,250
నేను ఒక కోసం నిల్వ డ్రైవర్లు రాశారు
enterprised superserver కంపెనీ

280
00:12:41,250 --> 00:12:42,470
తిరిగి '90.

281
00:12:42,470 --> 00:12:45,920
మరియు బాటమ్ లైన్ మరొక సాధిస్తూ ఉంది
నిల్వ శ్రేణి కేవలం ఏదో అని

282
00:12:45,920 --> 00:12:47,600
సంస్థలో ప్రతి రోజు జరిగింది.

283
00:12:47,600 --> 00:12:49,030
మరియు అది ఆగిపోయింది ఎప్పుడూ.

284
00:12:49,030 --> 00:12:52,690
ఎక్కువ సాంద్రతని నిల్వ డిమాండ్
అధిక సాంద్రత నిల్వ కోసం,

285
00:12:52,690 --> 00:12:56,340
మరియు మరింత సమర్ధమైన నిల్వకు
నిలిపివేశారు ఎప్పటికీ devices--.

286
00:12:56,340 --> 00:13:00,160
>> మరియు NoSQL ఒక గొప్ప సాంకేతికత
అది డేటా normalizes ఎందుకంటే.

287
00:13:00,160 --> 00:13:02,210
ఇది డేటా డి-నకిలీలు.

288
00:13:02,210 --> 00:13:07,180
ఇది ఒక నిర్మాణం లో డేటా ఉంచుతుంది
ప్రతి ప్రవేశ నమూనా అజ్ఞేయ ఉంది.

289
00:13:07,180 --> 00:13:11,600
బహుళ అప్లికేషన్లు నొక్కండి
SQL డేటాబేస్, తదర్థ ప్రశ్నలు అమలు,

290
00:13:11,600 --> 00:13:15,950
మరియు ఆకారం లో డేటా పొందుటకు వారు
వారి పనిభారములకు ప్రాసెస్ అవసరం.

291
00:13:15,950 --> 00:13:17,570
ఆ అద్భుతమైన ధ్వనులు.

292
00:13:17,570 --> 00:13:21,350
కానీ బాటమ్ లైన్ ఏ తో ఉంది
వ్యవస్థలో ప్రతిదీ అజ్ఞేయ ఉంటే,

293
00:13:21,350 --> 00:13:23,500
అది ఏమీ ఆప్టిమైజ్ ఉంది.

294
00:13:23,500 --> 00:13:24,050
అలాగే?

295
00:13:24,050 --> 00:13:26,386
>> మరియు మేము పొందడానికి ఏమిటి
రిలేషనల్ డేటాబేస్.

296
00:13:26,386 --> 00:13:27,510
ఇది నిల్వ ఆప్టిమైజ్.

297
00:13:27,510 --> 00:13:28,280
ఇది సామాన్యీకరణ వార్తలు.

298
00:13:28,280 --> 00:13:29,370
ఇది రిలేషనల్ వార్తలు.

299
00:13:29,370 --> 00:13:31,660
ఇది తాత్కాలిక ప్రశ్నలకు మద్దతు ఇస్తుంది.

300
00:13:31,660 --> 00:13:34,000
మరియు అది మరియు అది నిలువుగా ప్రమాణాల.

301
00:13:34,000 --> 00:13:39,030
>> నేను ఒక పెద్ద SQL డేటాబేస్ పొందాలి ఉంటే
లేదా మరింత శక్తివంతమైన SQL డేటాబేస్,

302
00:13:39,030 --> 00:13:41,090
నేను ఇనుము యొక్క ఒక పెద్ద ముక్క కొనుగోలు వెళ్ళండి.

303
00:13:41,090 --> 00:13:41,600
అలాగే?

304
00:13:41,600 --> 00:13:44,940
నేను వినియోగదారులు చాలా పని చేసిన
ప్రధాన నవీకరణలు ద్వారా ఉన్నాయని

305
00:13:44,940 --> 00:13:48,340
వారి SQL అవస్థాపనా మాత్రమే
ఆరు నెలల తరువాత తెలుసుకోవడానికి,

306
00:13:48,340 --> 00:13:49,750
వారు మళ్లీ గోడను కొట్టిన చేస్తున్నారు.

307
00:13:49,750 --> 00:13:55,457
మరియు ఒరాకిల్ లేదా MSSQL నుండి సమాధానం
లేదంటే ఎవరైనా ఒక పెద్ద బాక్స్ పొందుటకు ఉంది.

308
00:13:55,457 --> 00:13:58,540
బాగా ముందుగానే లేదా తరువాత, మీరు ఒక కొనుగోలు కాదు
బాక్స్ పెద్దది, మరియు నిజమైన సమస్య.

309
00:13:58,540 --> 00:14:00,080
మేము నిజంగా విషయాలు మార్చడానికి అవసరం.

310
00:14:00,080 --> 00:14:01,080
సో ఇక్కడ ఈ పని చేస్తుంది?

311
00:14:01,080 --> 00:14:06,560
ఇది ఆఫ్లైన్ బాగా పనిచేస్తుంది
విశ్లేషణలు, OLAP-రకం పనిఒత్తిళ్లు.

312
00:14:06,560 --> 00:14:08,670
SQL చెందినదే మరియు ఆ నిజంగా ఉంది.

313
00:14:08,670 --> 00:14:12,540
ఇప్పుడు, అనేక ఆన్లైన్ నేడు ఉపయోగిస్తారు
లావాదేవీ ప్రాసెసింగ్ రకం

314
00:14:12,540 --> 00:14:13,330
అప్లికేషన్లు.

315
00:14:13,330 --> 00:14:16,460
మరియు అది కేవలం జరిమానా పనిచేస్తుంది
వినియోగం కొంత స్థాయి,

316
00:14:16,460 --> 00:14:18,670
కానీ అది కేవలం స్కేల్ లేదు
NoSQL చేసే మార్గం.

317
00:14:18,670 --> 00:14:20,660
మరియు మేము కొద్దిగా మాట్లాడండి చేస్తాము
ఆ ఎందుకు గురించి బిట్.

318
00:14:20,660 --> 00:14:23,590
>> ఇప్పుడు, NoSQL, మరోవైపు,
మరింత గణన ఆప్టిమైజ్ ఉంది.

319
00:14:23,590 --> 00:14:24,540
అలాగే?

320
00:14:24,540 --> 00:14:26,830
దానికి అజ్ఞేయ కాదు
యాక్సెస్ నమూనా.

321
00:14:26,830 --> 00:14:31,620
మేము డి-సామాన్యీకరణ పిలుస్తాము
నిర్మాణం లేదా క్రమానుగతి నిర్మాణం.

322
00:14:31,620 --> 00:14:35,000
ఒక రిలేషనల్ డేటాబేస్ లో డేటా
బహుళ పట్టికలు నుండి ఏకమయ్యారు

323
00:14:35,000 --> 00:14:36,850
మీరు అవసరమైన వీక్షణ ఉత్పత్తి.

324
00:14:36,850 --> 00:14:40,090
ఒక NoSQL డేటాబేస్ లో డేటా
ఒక డాక్యుమెంట్ లో నిల్వ చేయబడిన

325
00:14:40,090 --> 00:14:42,100
తరతమ శ్రేణి నిర్మాణంలో కలిగి.

326
00:14:42,100 --> 00:14:45,670
సాధారణంగా ఉంటుంది అని డేటా అన్ని
ఆ దృశ్యం ఉత్పత్తి కలిసి చేరారు

327
00:14:45,670 --> 00:14:47,160
ఒక డాక్యుమెంటులో లో నిల్వ చేయబడుతుంది.

328
00:14:47,160 --> 00:14:50,990
మేము గురించి కొద్దిగా చర్చ చేస్తాము
ఎలా పటాలు ఒక జంట లో పనిచేస్తుంది.

329
00:14:50,990 --> 00:14:55,320
>> కానీ ఇక్కడ ఆలోచన మీరు నిల్వ ఉంది
ఈ ఇన్స్టాన్షియేట్ వీక్షణలు మీ డేటా.

330
00:14:55,320 --> 00:14:56,410
అలాగే?

331
00:14:56,410 --> 00:14:58,610
మీరు అడ్డంగా స్కేల్.

332
00:14:58,610 --> 00:14:59,556
కుడి?

333
00:14:59,556 --> 00:15:02,100
నేను పెంచడానికి అవసరం ఉంటే
నా NoSQL క్లస్టర్ పరిమాణం,

334
00:15:02,100 --> 00:15:03,700
నేను ఒక పెద్ద బాక్స్ పొందడానికి అవసరం లేదు.

335
00:15:03,700 --> 00:15:05,200
నేను మరో బాక్స్ పొందండి.

336
00:15:05,200 --> 00:15:07,700
మరియు నేను కలిసి ఆ క్లస్టర్
మరియు నేను ఆ డేటా పెంకు చేయవచ్చు.

337
00:15:07,700 --> 00:15:10,780
మేము గురించి కొంచెం చర్చ చేస్తాము
sharding ఏమిటి, అని

338
00:15:10,780 --> 00:15:14,270
డేటాబేస్ కొలమానము చేయగల
బహుళ భౌతిక పరికరాలు అంతటా

339
00:15:14,270 --> 00:15:18,370
నిర్వహణ మరియు అవరోధ తొలగించడానికి
నిలువుగా స్కేల్ నాకు నేర్పుతుంది.

340
00:15:18,370 --> 00:15:22,080
>> కనుక ఇది నిజంగా ఆన్లైన్ కోసం నిర్మించిన
లావాదేవీ ప్రాసెసింగ్ మరియు స్థాయి.

341
00:15:22,080 --> 00:15:25,480
ఒక పెద్ద తేడా ఉంది
ఇక్కడ రిపోర్టింగ్ మధ్య, కుడి?

342
00:15:25,480 --> 00:15:27,810
రిపోర్టింగ్, నాకు తెలీదు
ప్రశ్నలు నేను అడగండి వెళుతున్న.

343
00:15:27,810 --> 00:15:28,310
కుడి?

344
00:15:28,310 --> 00:15:30,570
Reporting-- ఎవరైనా నుండి ఉంటే
నా మార్కెటింగ్ శాఖ

345
00:15:30,570 --> 00:15:34,520
నా వినియోగదారులు ఎన్ని కేవలం కోరుకుంటున్నారు
ఈ ప్రత్యేక లక్షణం కలిగిన

346
00:15:34,520 --> 00:15:37,850
నాకు తెలీదు ఈ day-- కొనుగోలు
అవి ఏమి అడగవచ్చు చూడాలని విచారించారు.

347
00:15:37,850 --> 00:15:39,160
నేను అజ్ఞేయ ఉండాలి.

348
00:15:39,160 --> 00:15:41,810
>> ఇప్పుడు, ఒక ఆన్లైన్
లావాదేవీ అప్లికేషన్,

349
00:15:41,810 --> 00:15:43,820
నేను అడగడం నేను ఏమి ప్రశ్నలు తెలుసు.

350
00:15:43,820 --> 00:15:46,581
నేను అప్లికేషన్ నిర్మించారు
ఒక నిర్దిష్ట వర్క్ఫ్లో.

351
00:15:46,581 --> 00:15:47,080
అలాగే?

352
00:15:47,080 --> 00:15:50,540
నేను డేటా ఆప్టిమైజ్ చేస్తే
ఆ వర్క్ఫ్లో మద్దతు నిల్వ,

353
00:15:50,540 --> 00:15:52,020
అది వేగంగా చేస్తాడు.

354
00:15:52,020 --> 00:15:55,190
ఎందుకు NoSQL వార్తలు
నిజంగా డెలివరీ వేగవంతం

355
00:15:55,190 --> 00:15:57,710
సేవల ఆ రకాల.

356
00:15:57,710 --> 00:15:58,210
అయితే సరే.

357
00:15:58,210 --> 00:16:00,501
>> కాబట్టి మేము పొందడానికి వెళుతున్న
ఇక్కడ సిద్ధాంతం యొక్క ఒక చిన్న బిట్.

358
00:16:00,501 --> 00:16:03,330
మరియు మీరు కొన్ని, మీ కళ్ళు
కొద్దిగా వెనక్కి ఉండవచ్చు.

359
00:16:03,330 --> 00:16:06,936
కానీ నేను ఉంచడానికి ప్రయత్నించండి చేస్తాము
నేను వంటి అధిక స్థాయి.

360
00:16:06,936 --> 00:16:08,880
మీరు ప్రాజెక్ట్ లో ఉన్నారు కనుక
నిర్వహణ, ఉన్నాయి

361
00:16:08,880 --> 00:16:12,280
నిర్మాణం అంటారు
అడ్డంకులకు త్రిభుజం.

362
00:16:12,280 --> 00:16:12,936
అలాగే.

363
00:16:12,936 --> 00:16:16,060
కోయ ఆజ్ఞలను త్రిభుజం
మీరు ప్రతిదీ అన్ని సమయం కాదు.

364
00:16:16,060 --> 00:16:17,750
మీ పై మరియు ఇది చాలా తినడానికి కాదు.

365
00:16:17,750 --> 00:16:22,310
కాబట్టి ప్రాజెక్ట్ నిర్వహణ, ఆ త్రిభుజం
పరిమితులు, మీరు దానిని చౌకగా కలిగి ఉంది

366
00:16:22,310 --> 00:16:24,710
మీరు, వేగవంతమైన కలిగి
లేదా మీరు మంచి ఉండవచ్చు.

367
00:16:24,710 --> 00:16:25,716
రెండు ఎంచుకోండి.

368
00:16:25,716 --> 00:16:27,090
మీరు మూడు ఉండకూడదు ఎందుకంటే.

369
00:16:27,090 --> 00:16:27,460
కుడి?

370
00:16:27,460 --> 00:16:27,820
అలాగే.

371
00:16:27,820 --> 00:16:28,920
>> కాబట్టి మీరు ఈ చాలా గురించి వినటానికి.

372
00:16:28,920 --> 00:16:31,253
ఇది ఒక ట్రిపుల్ నిరోధ వార్తలు
ట్రిపుల్ నిరోధ త్రిభుజం,

373
00:16:31,253 --> 00:16:34,420
లేదా ఇనుము త్రిభుజం oftentimes-- ఉంది
మీరు నిర్వాహకులు అంటున్నారు మాట్లాడినప్పుడు,

374
00:16:34,420 --> 00:16:35,420
వారు ఈ గురించి మాట్లాడదాము.

375
00:16:35,420 --> 00:16:37,640
ఇప్పుడు, డేటాబేస్ కలిగి
వారి సొంత ఇనుము త్రిభుజం.

376
00:16:37,640 --> 00:16:40,350
మరియు డేటా యొక్క ఇనుము త్రిభుజం
మేము CAP సిద్ధాంతం కాల్ ఏమిటి.

377
00:16:40,350 --> 00:16:41,580
అలాగే?

378
00:16:41,580 --> 00:16:43,770
>> CAP సిద్ధాంతం ఆజ్ఞలను
ఎలా డేటాబేస్ పనిచేస్తాయి

379
00:16:43,770 --> 00:16:45,627
ఒక నిర్దిష్ట పరిస్థితి కింద.

380
00:16:45,627 --> 00:16:47,460
మేము గురించి మాట్లాడదాము
ఆ పరిస్థితి ఏమిటి.

381
00:16:47,460 --> 00:16:52,221
కానీ త్రిభుజంలోని మూడు పాయింట్లు,
కాబట్టి, సి ఉంటాయి, స్థిరత్వం మాట్లాడటం.

382
00:16:52,221 --> 00:16:52,720
అలాగే?

383
00:16:52,720 --> 00:16:56,760
కాబట్టి క్యాప్, నిలకడ అన్ని అర్థం
డేటాబేస్ యాక్సెస్ ఎవరు ఖాతాదారులకు

384
00:16:56,760 --> 00:16:59,084
ఎల్లప్పుడూ చాలా ఉంటుంది
డేటా స్థిరమైన వీక్షణ.

385
00:16:59,084 --> 00:17:00,750
ఎవరూ చేసుకొనును రెండు వేర్వేరు విషయాలు చూడండి.

386
00:17:00,750 --> 00:17:01,480
అలాగే?

387
00:17:01,480 --> 00:17:04,020
నేను డేటాబేస్ చూసినట్లయితే,
నేను అదే అభిప్రాయం చూసిన వెబ్

388
00:17:04,020 --> 00:17:06,130
నా భాగస్వామి ఎవరు చూస్తాడు
అదే డేటాబేస్.

389
00:17:06,130 --> 00:17:07,470
ఆ అనుగుణ్యత వార్తలు.

390
00:17:07,470 --> 00:17:12,099
>> అందుబాటు అంటే ఉంటే
డేటాబేస్ ఆన్లైన్, అది చేరవచ్చు ఉంటే,

391
00:17:12,099 --> 00:17:14,760
అన్ని ఖాతాదారులకు ఎల్లప్పుడూ రెడీ ఆ
చదవడం మరియు వ్రాయడం చెయ్యలేరు.

392
00:17:14,760 --> 00:17:15,260
అలాగే?

393
00:17:15,260 --> 00:17:17,010
కాబట్టి ప్రతి క్లయింట్
డేటాబేస్ చదువుకోవచ్చు

394
00:17:17,010 --> 00:17:18,955
ఎల్లప్పుడూ సామర్థ్యాన్ని రీడ్ ఉంటుంది
డేటా మరియు వ్రాయడం డేటా.

395
00:17:18,955 --> 00:17:21,819
ఆ సందర్భంలో ఉంటే,
అది ఒక అందుబాటులో వ్యవస్థ.

396
00:17:21,819 --> 00:17:24,230
>> మరియు మూడవ పాయింట్ ఏమిటి
దేశ విభజన సహనం కాల్.

397
00:17:24,230 --> 00:17:24,730
అలాగే?

398
00:17:24,730 --> 00:17:28,160
విభజన సహనం అంటే
వ్యవస్థ బాగా పనిచేస్తుంది

399
00:17:28,160 --> 00:17:32,000
భౌతిక నెట్వర్క్ ఉన్నప్పటికీ
నోడ్స్ మధ్య విభజనలు.

400
00:17:32,000 --> 00:17:32,760
అలాగే?

401
00:17:32,760 --> 00:17:36,270
కాబట్టి క్లస్టర్ నోడ్స్ కాదు
ప్రతి ఇతర మాట్లాడటానికి, ఏమి జరుగుతుంది?

402
00:17:36,270 --> 00:17:36,880
అయితే సరే.

403
00:17:36,880 --> 00:17:39,545
>> కాబట్టి రిలేషనల్ డేటాబేస్ choose--
మీరు ఈ రెండు ఎంచుకోవచ్చు.

404
00:17:39,545 --> 00:17:40,045
అలాగే.

405
00:17:40,045 --> 00:17:43,680
కాబట్టి రిలేషనల్ డేటాబేస్ ఎంచుకోండి
స్థిరమైన మరియు అందుబాటులో ఉండాలి.

406
00:17:43,680 --> 00:17:47,510
విభజన మధ్య జరిగితే
డేటా స్టోర్ లో DataNodes,

407
00:17:47,510 --> 00:17:48,831
డేటాబేస్ కూలిపోతుంది.

408
00:17:48,831 --> 00:17:49,330
కుడి?

409
00:17:49,330 --> 00:17:50,900
ఇది కేవలం పని చెయ్యకపోతే.

410
00:17:50,900 --> 00:17:51,450
అలాగే.

411
00:17:51,450 --> 00:17:54,230
>> మరియు ఈ అవి ఎందుకు
పెద్ద పెట్టెలు పెరగడం.

412
00:17:54,230 --> 00:17:54,730
కుడి?

413
00:17:54,730 --> 00:17:58,021
No-- సాధారణంగా ఒక క్లస్టర్ ఉంది ఎందుకంటే
డేటాబేస్, వాటిలో చాలా చాలా అక్కడ కాదు

414
00:17:58,021 --> 00:17:59,590
ఆ విధంగా పనిచేస్తాయి.

415
00:17:59,590 --> 00:18:03,019
కానీ చాలా డేటాబేస్ స్కేల్
నిలువుగా ఒక బాక్స్ లోపల.

416
00:18:03,019 --> 00:18:05,060
వారు ఉండాలి ఎందుకంటే
స్థిరమైన మరియు అందుబాటులో.

417
00:18:05,060 --> 00:18:10,320
విభజన లోపలికి ఉన్నట్లయితే,
అప్పుడు మీరు ఒక ఎంపిక చేయడానికి కలిగి ఉంటుంది.

418
00:18:10,320 --> 00:18:13,720
మీరు మధ్య ఎంపిక చేసుకోవాలి
స్థిరమైన మరియు అందుబాటులో ఉండటం.

419
00:18:13,720 --> 00:18:16,080
>> మరియు ఆ NoSQL డేటాబేస్ ఏమి ఉంది.

420
00:18:16,080 --> 00:18:16,580
అయితే సరే.

421
00:18:16,580 --> 00:18:20,950
సో ఒక NoSQL డేటాబేస్, అది
రెండు రుచులలో వస్తుంది.

422
00:18:20,950 --> 00:18:22,990
మేము బాగా తెలియజేయండి
ఎన్నో రుచులు వస్తుంది,

423
00:18:22,990 --> 00:18:26,140
కానీ అది రెండు ప్రాథమిక వస్తుంది
ఏమి characteristics--

424
00:18:26,140 --> 00:18:30,050
మేము CP డేటాబేస్, లేదా ఒక అంటారని
స్థిరమైన మరియు విభజన సహనం

425
00:18:30,050 --> 00:18:31,040
వ్యవస్థ.

426
00:18:31,040 --> 00:18:34,930
ఈ అబ్బాయిలు ఎంపిక చేస్తే ఆ
నోడ్స్, ప్రతి ఇతర తో పరిచయం కోల్పోతారు

427
00:18:34,930 --> 00:18:37,091
మేము అనుమతించిన వెళ్ళడం లేదు చేస్తున్నాం
ప్రజలు ఏ మరింత వ్రాయడానికి.

428
00:18:37,091 --> 00:18:37,590
అలాగే?

429
00:18:37,590 --> 00:18:41,855
>> విభజన తొలగించబడుతుంది వరకు,
వ్రాసే యాక్సెస్ నిరోధించబడింది.

430
00:18:41,855 --> 00:18:43,230
వారు అందుబాటులో లేరు అర్థం.

431
00:18:43,230 --> 00:18:44,510
వారు స్థిరమైన ఉన్నారు.

432
00:18:44,510 --> 00:18:46,554
మేము ఆ చూసినప్పుడు
విభజన తనకు తానుగా ఇంజెక్ట్,

433
00:18:46,554 --> 00:18:48,470
మేము ఇప్పుడు స్థిరంగా ఉంటాయి
మేము కావడం లేదు ఎందుకంటే

434
00:18:48,470 --> 00:18:51,517
రెండు డేటా మార్పు అనుమతించేందుకు
స్వతంత్రంగా విభజన పక్కలు

435
00:18:51,517 --> 00:18:52,100
ఒకదానికొకటి.

436
00:18:52,100 --> 00:18:54,130
మేము ఉంటుంది
కమ్యూనికేషన్ reestablish

437
00:18:54,130 --> 00:18:56,930
ఏ నవీకరణ ముందు
డేటా అనుమతి.

438
00:18:56,930 --> 00:18:58,120
అలాగే?

439
00:18:58,120 --> 00:19:02,650
>> తదుపరి రుచి, ఒక AP వ్యవస్థ ఉంటుంది
లేదా అందుబాటులో మరియు విభజించబడిన

440
00:19:02,650 --> 00:19:03,640
సహనం వ్యవస్థ.

441
00:19:03,640 --> 00:19:05,320
ఈ అబ్బాయిలు పట్టించుకోను.

442
00:19:05,320 --> 00:19:06,020
కుడి?

443
00:19:06,020 --> 00:19:08,960
ఒక అందుతుంది అని ఏదైనా నోడ్
మేము అది తీసుకొని వెళ్తాము, వ్రాయండి.

444
00:19:08,960 --> 00:19:11,480
నేను నా డేటా పునరావృత్తం చేస్తున్నాను
బహుళ నోడ్లు అంతటా.

445
00:19:11,480 --> 00:19:14,730
ఈ నోడ్స్ క్లయింట్, క్లయింట్ వస్తుంది
, చెప్పారు, నేను కొన్ని డేటా రాయాలో.

446
00:19:14,730 --> 00:19:16,300
నోడ్ ఏ సమస్య, చెప్పారు.

447
00:19:16,300 --> 00:19:18,580
నోడ్ అతనికి అందుతుంది పక్కన
అదే రికార్డు లో వ్రాయండి,

448
00:19:18,580 --> 00:19:20,405
అతను ఏ సమస్య చెప్పటానికి జరగబోతోంది.

449
00:19:20,405 --> 00:19:23,030
ఎక్కడో తిరిగి తిరిగి చివరికి,
ఆ డేటా నకలు జరగబోతోంది.

450
00:19:23,030 --> 00:19:27,360
ఆపై ఎవరైనా తెలుసుకోవటం జరగబోతోంది
UH-OH, గ్రహిస్తారు వారు సిస్టమ్, ఊ-OH,

451
00:19:27,360 --> 00:19:28,870
రెండు వైపులా ఒక నవీకరణ ఉన్నాయి.

452
00:19:28,870 --> 00:19:30,370
మేము ఏమి చేయాలి?

453
00:19:30,370 --> 00:19:33,210
మరియు వారు అప్పుడు ఏమి ఉంది
వారు ఏదో ఇవి

454
00:19:33,210 --> 00:19:36,080
వాటిని ఆ డేటా రాష్ట్రంలో పరిష్కరించడానికి అనుమతిస్తుంది.

455
00:19:36,080 --> 00:19:39,000
మేము గురించి మాట్లాడదాము
తదుపరి చార్టులో ఆ.

456
00:19:39,000 --> 00:19:40,000
>> విషయం ఇక్కడ అభిప్రాయపడుతున్నారు.

457
00:19:40,000 --> 00:19:42,374
మరియు నేను చాలా పొందడానికి వెళుతున్న కాదు
చాలా ఈ లోకి, ఈ ఎందుకంటే

458
00:19:42,374 --> 00:19:43,510
లోతైన డేటా సిద్ధాంతం భరోసా.

459
00:19:43,510 --> 00:19:46,670
కానీ ఒక లావాదేవీ ఉంది
ఫ్రేమ్ ఆ

460
00:19:46,670 --> 00:19:50,680
ఒక రిలేషనల్ వ్యవస్థ నడుస్తుంది
నాకు సురక్షితంగా నవీకరణలను చేయడానికి అనుమతిస్తుంది

461
00:19:50,680 --> 00:19:53,760
డేటాబేస్ లో బహుళ సంస్థలకు.

462
00:19:53,760 --> 00:19:58,320
మరియు ఆ నవీకరణలు జరుగుతుంది
ఒకేసారి లేదా అన్ని వద్ద.

463
00:19:58,320 --> 00:20:00,500
మరియు ఈ ఆమ్లం లావాదేవీలు అంటారు.

464
00:20:00,500 --> 00:20:01,000
అలాగే?

465
00:20:01,000 --> 00:20:06,570
>> యాసిడ్, మాకు నిలకడ పరమాణు ఇస్తుంది,
ఒంటరిగా, మరియు మన్నిక.

466
00:20:06,570 --> 00:20:07,070
అలాగే?

467
00:20:07,070 --> 00:20:13,550
వారందరును అణు, లావాదేవీలు అర్థం
నా అప్డేట్స్ జరిగే గాని లేదా వారు లేదు.

468
00:20:13,550 --> 00:20:16,570
క్రమబద్ధత అర్థం
డేటాబేస్ ఎప్పుడూ రెడీ

469
00:20:16,570 --> 00:20:19,780
ఒక స్థిరమైన తేవాలని
నవీకరణను తర్వాత రాష్ట్ర.

470
00:20:19,780 --> 00:20:23,900
నేను ఒక డేటాబేస్ వదిలి ఎప్పటికీ
ఒక నవీకరణ దరఖాస్తు తర్వాత దుస్థితిలో.

471
00:20:23,900 --> 00:20:24,400
అలాగే?

472
00:20:24,400 --> 00:20:26,720
>> కనుక ఇది కొద్దిగా వివిధ
CAP నిలకడ కంటే.

473
00:20:26,720 --> 00:20:29,760
CAP నిలకడ అర్థం నా
ఖాతాదారులకు ఎల్లప్పుడూ డేటా చూడగలరు.

474
00:20:29,760 --> 00:20:34,450
యాసిడ్ నిలకడ అర్థం ఉన్నప్పుడు
ఒక లావాదేవీ డేటా యొక్క మంచి, ప్రదర్శనతో.

475
00:20:34,450 --> 00:20:35,709
నా సంబంధాలు అన్ని బాగున్నాయి.

476
00:20:35,709 --> 00:20:38,750
నేను ఒక పేరెంట్ వరుస తొలగించవచ్చు వెళుతున్న కాదు
మరియు అనాధ పిల్లలు ఒక సమూహం వదిలి

477
00:20:38,750 --> 00:20:40,970
కొన్ని ఇతర పట్టికలో.

478
00:20:40,970 --> 00:20:44,320
నేను స్థిరమైన ఉన్నాను ఉంటే అది జరగలేదు చేయవచ్చు
ఒక ఆమ్లం లావాదేవీ.

479
00:20:44,320 --> 00:20:49,120
>> ఏకాంతవాసం లావాదేవీలు అర్థం
ఎల్లప్పుడూ ఇతర తరువాత ఒక పెంచాలి.

480
00:20:49,120 --> 00:20:51,920
డేటా ముగింపు ఫలితం
అదే రాష్ట్రంలో ఉంటుంది

481
00:20:51,920 --> 00:20:54,770
ఆ లావాదేవీల ఉంటే
ఆ పాటే జారీ చేశారు

482
00:20:54,770 --> 00:20:57,340
వరుసక్రమమలో ఉరితీయబడ్డారు.

483
00:20:57,340 --> 00:21:00,030
కనుక ఇది అనుకూలత వార్తలు
డేటాబేస్ లో నియంత్రణ.

484
00:21:00,030 --> 00:21:04,130
కాబట్టి ప్రాథమికంగా, నేను పెంచడం కాదు
రెండుసార్లు రెండు ప్రక్రియలు అదే విలువ.

485
00:21:04,130 --> 00:21:08,580
>> కానీ నేను ఈ విలువ 1 జోడించండి చెప్పుకోవాలంటే,
మరియు రెండు లావాదేవీలు వస్తాయి

486
00:21:08,580 --> 00:21:10,665
మరియు ఒకటి, దీన్ని ప్రయత్నించండి
మొదటి అక్కడ పొందుటకు వెళ్తున్నారు

487
00:21:10,665 --> 00:21:12,540
మరియు ఇతర ఒకరి
తర్వాత అక్కడ పొందడానికి వెళ్తున్నారు.

488
00:21:12,540 --> 00:21:15,210
సో ముగింపు లో, నేను రెండు జోడించారు.

489
00:21:15,210 --> 00:21:16,170
మీరు వాట్ ఐ మీన్ చూడండి?

490
00:21:16,170 --> 00:21:16,670
అలాగే.

491
00:21:16,670 --> 00:21:19,220

492
00:21:19,220 --> 00:21:21,250
>> మన్నిక అందంగా సూటిగా ఉంటుంది.

493
00:21:21,250 --> 00:21:23,460
చేసినప్పుడు లావాదేవీ
గుర్తించబడింది, అంతే

494
00:21:23,460 --> 00:21:26,100
కూడా అక్కడ మాత్రం
వ్యవస్థ క్రాష్ అయితే.

495
00:21:26,100 --> 00:21:29,230
ఆ వ్యవస్థ కోలుకోవడంతో, ఆ
కట్టుబడి ఉందని లావాదేవీ

496
00:21:29,230 --> 00:21:30,480
నిజానికి అక్కడ అవతరిస్తుంది.

497
00:21:30,480 --> 00:21:33,130
కాబట్టి ఆ హామీలు వార్తలు
యాసిడ్ లావాదేవీల.

498
00:21:33,130 --> 00:21:35,470
ఆ అందంగా nice హామీలు ఉన్నాయి
ఒక డేటాబేస్ లో కలిగి,

499
00:21:35,470 --> 00:21:36,870
కానీ వారు ఆ ఖర్చుతో వచ్చి.

500
00:21:36,870 --> 00:21:37,640
కుడి?

501
00:21:37,640 --> 00:21:40,520
>> సమస్య ఎందుకంటే
ఈ ప్రణాళిక తో

502
00:21:40,520 --> 00:21:44,540
డేటా లో ఒక విభజనను ఉందనుకోండి
సెట్, నేను ఒక నిర్ణయం ఉంటుంది.

503
00:21:44,540 --> 00:21:48,000
నేను అనుమతించాలి వెళుతున్న
ఒక వైపు లేదా ఇతర న నవీకరణలు.

504
00:21:48,000 --> 00:21:50,310
మరియు ఆ జరిగితే,
అప్పుడు నేను ఇకపై వెళుతున్న

505
00:21:50,310 --> 00:21:52,630
కాపాడుకుంది ఉండాలి
ఆ లక్షణాలు.

506
00:21:52,630 --> 00:21:53,960
వారు స్థిరమైన వుండదు.

507
00:21:53,960 --> 00:21:55,841
వారు వివిక్త కాదు.

508
00:21:55,841 --> 00:21:58,090
అది విచ్ఛిన్నం ఇక్కడ ఈ ఉంది
రిలేషనల్ డేటాబేస్.

509
00:21:58,090 --> 00:22:01,360
ఈ కారణంగా రిలేషనల్ ఉంది
డేటాబేస్ నిలువుగా స్కేల్.

510
00:22:01,360 --> 00:22:05,530
>> మరోవైపు, మేము కలిగి
ఏమి BASE టెక్నాలజీ అని.

511
00:22:05,530 --> 00:22:07,291
మరియు ఈ మీ NoSQL డేటాబేస్లు ఉంటాయి.

512
00:22:07,291 --> 00:22:07,790
అయితే సరే.

513
00:22:07,790 --> 00:22:10,180
కాబట్టి మేము మా CP, AP డేటాబేస్ కలిగి.

514
00:22:10,180 --> 00:22:14,720
మరియు ఈ మీరు ప్రాథమికంగా అంటాము
అందుబాటులో మృదువైన రాష్ట్ర, చివరికి

515
00:22:14,720 --> 00:22:15,740
స్థిరమైన.

516
00:22:15,740 --> 00:22:16,420
అలాగే?

517
00:22:16,420 --> 00:22:19,690
>> సాధారణంగా అందుబాటులో ఎందుకంటే
వారు విభజన సహనంతో ఉన్నారు.

518
00:22:19,690 --> 00:22:21,470
వారు ఎల్లప్పుడూ ఉంటుంది
అక్కడ, అక్కడ అయినా

519
00:22:21,470 --> 00:22:23,053
నోడ్స్ మధ్య ఒక నెట్ విభజన.

520
00:22:23,053 --> 00:22:25,900
నేను ఒక నోడ్ మాట్లాడవచ్చు ఉంటే, నేను రెడీ
డేటా చదువుతారు అవతరిస్తుంది.

521
00:22:25,900 --> 00:22:26,460
అలాగే?

522
00:22:26,460 --> 00:22:30,810
నేను ఎల్లప్పుడూ రాయడానికి పోవచ్చును
డేటా నేను ఒక స్థిరమైన వేదిక ఉన్నాను ఉంటే.

523
00:22:30,810 --> 00:22:32,130
కానీ నేను డేటా చదవడానికి చేయగలరు.

524
00:22:32,130 --> 00:22:34,960

525
00:22:34,960 --> 00:22:38,010
>> మృదువైన రాష్ట్ర సూచిస్తుంది
నేను ఆ డేటా చదివినపుడు ఆ

526
00:22:38,010 --> 00:22:40,790
ఇతర నోడ్స్ అదే కాదు.

527
00:22:40,790 --> 00:22:43,390
హక్కు ఒక నోడ్ న జారీ చేయబడింది ఉంటే
క్లస్టర్ లో వేరే ఎక్కడా

528
00:22:43,390 --> 00:22:46,650
మరియు అది అంతటా ప్రతిరూప లేదు
క్లస్టర్ ఇంకా నేను, ఆ డేటా చదివినపుడు

529
00:22:46,650 --> 00:22:48,680
ఆ రాష్ట్ర స్థిరమైన కాదు.

530
00:22:48,680 --> 00:22:51,650
అయితే, ఇది ఉంటుంది
చివరికి స్థిరమైన,

531
00:22:51,650 --> 00:22:53,870
అంటే ఒక వ్రాయడం
వ్యవస్థ చేస్తారు,

532
00:22:53,870 --> 00:22:56,480
ఇది నోడ్స్ అంతటా నకలు ఉంటుంది.

533
00:22:56,480 --> 00:22:59,095
మరియు చివరికి, ఆ రాష్ట్ర
క్రమంలో అందుతుంది,

534
00:22:59,095 --> 00:23:00,890
మరియు ఇది ఒక స్థిరమైన స్థితిలో ఉంటుంది.

535
00:23:00,890 --> 00:23:05,000
>> ఇప్పుడు, CAP సిద్ధాంతం నిజంగా
మాత్రమే ఒక షరతు ఆడుతుంది.

536
00:23:05,000 --> 00:23:08,700
ఇది సంభవించినప్పుడు ఆ పరిస్థితి.

537
00:23:08,700 --> 00:23:13,710
ఎప్పుడు లో పనిచేస్తే ఎందుకంటే
సాధారణ మోడ్, యే విభజన ఉంది,

538
00:23:13,710 --> 00:23:16,370
ప్రతిదీ యొక్క స్థిరమైన మరియు అందుబాటులో.

539
00:23:16,370 --> 00:23:19,990
మీరు మాత్రమే CAP గురించి ఆందోళన
మేము ఆ విభజన ఉన్నప్పుడు.

540
00:23:19,990 --> 00:23:21,260
కాబట్టి ఆ అరుదు.

541
00:23:21,260 --> 00:23:25,360
కానీ వ్యవస్థ ఉన్నప్పుడు ఆ ప్రతిస్పందిస్తుంది ఎలా
వ్యవస్థ ఏ రకం ఖరారు సంభవిస్తుంటాయి

542
00:23:25,360 --> 00:23:26,750
మేము వ్యవహరించే చేస్తున్నారు.

543
00:23:26,750 --> 00:23:31,110
>> కాబట్టి యొక్క పరిశీలించి తెలియజేయండి
ఆ AP వ్యవస్థలు కోసం అనిపిస్తోంది.

544
00:23:31,110 --> 00:23:32,621
అలాగే?

545
00:23:32,621 --> 00:23:34,830
AP వ్యవస్థలు రెండు రుచులలో వస్తుంది.

546
00:23:34,830 --> 00:23:38,514
వారు ఒక అని రుచి వస్తాయి
మాస్టర్ మాస్టర్, ఎల్లప్పుడూ అందుబాటులో 100%.

547
00:23:38,514 --> 00:23:40,430
మరియు వారు వస్తాయి
చెప్పారు ఇది ఇతర రుచి,

548
00:23:40,430 --> 00:23:43,330
మీరు, నేను ఆందోళన వెళుతున్న ఏమి
ఈ విభజనీకరణ విషయం గురించి

549
00:23:43,330 --> 00:23:44,724
ఒక వాస్తవ విభజన జరుగుతుంది.

550
00:23:44,724 --> 00:23:47,890
లేకపోతే, ప్రాధమిక ఉన్నట్లు జరగబోతోంది
హక్కుల తీసుకోవాలని జరగబోతోంది ఎవరు నోడ్స్.

551
00:23:47,890 --> 00:23:48,500
అలాగే?

552
00:23:48,500 --> 00:23:50,040
>> కాసాండ్రా వంటి మేము ఏదో చేస్తే.

553
00:23:50,040 --> 00:23:54,440
కాసాండ్రా ఒక మాస్టర్ అవుతుంది
మాస్టర్, నాకు ఏ నోడ్ వ్రాయండి చేసుకుందాం.

554
00:23:54,440 --> 00:23:55,540
కనుక ఏమి జరుగుతుంది?

555
00:23:55,540 --> 00:23:58,270
కాబట్టి నేను ఒక వస్తువు
రెండు నోడ్స్ మీద ఉందని డేటాబేస్.

556
00:23:58,270 --> 00:24:01,705
ఆ వస్తువు ఎస్ కాల్ లెట్
కాబట్టి మేము S. కోసం రాష్ట్ర కలిగి

557
00:24:01,705 --> 00:24:04,312
మేము కొన్ని కార్యకలాపాలను కలిగి
S న జరుగుతున్న అని.

558
00:24:04,312 --> 00:24:06,270
కాసాండ్రా నాకు అనుమతిస్తుంది
బహుళ నోడ్లు వ్రాయండి.

559
00:24:06,270 --> 00:24:08,550
కాబట్టి యొక్క నేను ఒక పొందుటకు చెప్పే వీలు
రెండు నోడ్స్ s కోసం వ్రాయండి.

560
00:24:08,550 --> 00:24:12,274
బాగా, ఏమి అప్ సంభవించే ముగుస్తుంది
మేము ఒక విభజనీకరణ ఈవెంట్ కాల్.

561
00:24:12,274 --> 00:24:14,190
ఉండకపోవచ్చు ఒక
భౌతిక నెట్వర్క్ విభజన.

562
00:24:14,190 --> 00:24:15,950
కానీ ఎందుకంటే డిజైన్
వ్యవస్థ, అంతే

563
00:24:15,950 --> 00:24:18,449
నిజానికి వెంటనే విభజించుట
నేను రెండు నోడ్స్ న ఒక వ్రాయడం పొందండి.

564
00:24:18,449 --> 00:24:20,830
ఇది నాకు బలవంతంగా కాదు
ఒక నోడ్ ద్వారా అన్ని వ్రాయండి.

565
00:24:20,830 --> 00:24:22,340
నేను రెండు నోడ్స్ న రాయడం వెబ్.

566
00:24:22,340 --> 00:24:23,330
అలాగే?

567
00:24:23,330 --> 00:24:25,740
>> కాబట్టి ఇప్పుడు నేను రెండు రాష్ట్రాలు.

568
00:24:25,740 --> 00:24:26,360
అలాగే?

569
00:24:26,360 --> 00:24:28,110
ఏం జరగబోతోంది
ముందుగానే లేదా తరువాత

570
00:24:28,110 --> 00:24:29,960
ఒక ప్రతికృతి ఈవెంట్ ఉన్నట్లు జరగబోతోంది.

571
00:24:29,960 --> 00:24:33,300
ఉన్నట్లు జరగబోతోంది ఏమి మేము
విభజన రికవరీ, ఇది పిలుపునిచ్చింది

572
00:24:33,300 --> 00:24:35,200
ఇక్కడ ఈ రెండు
రాష్ట్రాలు కలిసి తిరిగి వచ్చి

573
00:24:35,200 --> 00:24:37,310
ఒక అల్గోరిథం ఉన్నట్లు జరగబోతోంది
ఆ, డేటాబేస్ లోపల నడుస్తుంది

574
00:24:37,310 --> 00:24:38,540
ఏమి నిర్ణయించుకుంటుంది.

575
00:24:38,540 --> 00:24:39,110
అలాగే?

576
00:24:39,110 --> 00:24:43,057
అప్రమేయంగా, చివరి నవీకరణ
అత్యంత AP వ్యవస్థల్లో విజయాలు.

577
00:24:43,057 --> 00:24:44,890
కాబట్టి సాధారణంగా ఉంది ఒక
డిఫాల్ట్ అల్గోరిథం ఏమి

578
00:24:44,890 --> 00:24:47,400
వారు ఒక బ్యాక్ కాల్
ఫంక్షన్, ఏదో

579
00:24:47,400 --> 00:24:51,000
ఈ స్థితి అని ఉంటుంది
కొన్ని తర్కం అమలు చేయడం జరుగుతుంది

580
00:24:51,000 --> 00:24:52,900
ఆ వివాదం పరిష్కరించడానికి.

581
00:24:52,900 --> 00:24:53,850
అలాగే?

582
00:24:53,850 --> 00:24:58,770
డిఫాల్ట్ బ్యాక్ మరియు డిఫాల్ట్
అత్యంత AP డేటాబేస్ లో పరిష్కర్త

583
00:24:58,770 --> 00:25:01,130
ఉంది, స్టాంప్ విజయాలు ఏమి అంచనా.

584
00:25:01,130 --> 00:25:02,380
ఈ చివరి నవీకరణ ఉంది.

585
00:25:02,380 --> 00:25:04,320
నేను అక్కడ ఆ నవీకరణ ఉంచారు వెళుతున్న.

586
00:25:04,320 --> 00:25:08,440
నేను ఈ రికార్డ్ డంప్ ఉండవచ్చు నేను
ఒక రికవరీ లాగ్ లోకి ఆఫ్ కురిపించింది

587
00:25:08,440 --> 00:25:11,670
యూజర్ తరువాత తిరిగి వచ్చి, తద్వారా
మరియు చెప్పటానికి, హే, ఘర్షణ ఉంది.

588
00:25:11,670 --> 00:25:12,320
ఏం జరిగింది?

589
00:25:12,320 --> 00:25:16,370
మరియు మీరు నిజంగానే రికార్డు డంప్ చేయగలుగుతారు
అన్ని ప్రమాదాలలో మరియు ఉపసంహరణలను

590
00:25:16,370 --> 00:25:17,550
మరియు ఏమి చూడండి.

591
00:25:17,550 --> 00:25:21,580
>> ఇప్పుడు, ఒక యూజర్ గా, మీరు కూడా
ఆ బ్యాక్ లోకి తర్కం ఉన్నాయి.

592
00:25:21,580 --> 00:25:24,290
కాబట్టి మీరు ఆ మార్చవచ్చు
బ్యాక్ ఆపరేషన్.

593
00:25:24,290 --> 00:25:26,730
మీరు హే, నేను కావలసిన చెప్పగలదు
ఈ డేటాను సరిచేయడానికి.

594
00:25:26,730 --> 00:25:28,880
నేను ప్రయత్నించండి అనుకుంటున్నారా మరియు
ఆ రెండు రికార్డులు విలీనం.

595
00:25:28,880 --> 00:25:30,050
కానీ ఆ మీకు అనిపిస్తుంది.

596
00:25:30,050 --> 00:25:32,880
డేటాబేస్ తెలీదు ఎలా
అప్రమేయంగా అలా. సమయం చాలా,

597
00:25:32,880 --> 00:25:34,850
మాత్రమే విషయం డేటాబేస్
ఎలా చెప్పాలి చేయాలని తెలుసు,

598
00:25:34,850 --> 00:25:36,100
ఈ ఒక చివరి రికార్డ్గా చెప్పవచ్చు.

599
00:25:36,100 --> 00:25:39,183
ఆ, గెలుచుకున్న జరగబోతోంది ఆ ఒకటి
మరియు ఆ నేను ఉంచారు వెళుతున్న విలువ ఉంది.

600
00:25:39,183 --> 00:25:41,490
విభజన రికవరీ ఒకసారి
మరియు ప్రతికృతి, సంభవిస్తుంది

601
00:25:41,490 --> 00:25:43,930
మేము మా రాష్ట్ర, కలిగిన
ఇప్పుడు ఇది ప్రధాన S

602
00:25:43,930 --> 00:25:46,890
అన్ని ఆ వస్తువుల విలీనంతో రాష్ట్ర.

603
00:25:46,890 --> 00:25:49,700
కాబట్టి AP వ్యవస్థలు ఈ కలిగి.

604
00:25:49,700 --> 00:25:51,615
CP వ్యవస్థలు అవసరం లేదు
ఈ గురించి ఆందోళన.

605
00:25:51,615 --> 00:25:54,490
వెంటనే విభజనను వస్తుంది ఎందుకంటే
తెరపైకి, వారు కేవలం తీసుకొని ఆపడానికి

606
00:25:54,490 --> 00:25:55,530
రాశారు.

607
00:25:55,530 --> 00:25:56,180
అలాగే?

608
00:25:56,180 --> 00:25:58,670
కాబట్టి ఆ చాలా సులభం
స్థిరమైన ఉండటం ఎదుర్కోవటానికి

609
00:25:58,670 --> 00:26:01,330
మీరు ఏ నవీకరణలను అంగీకరించరు.

610
00:26:01,330 --> 00:26:04,620
CP వ్యవస్థలను తో ఆ.

611
00:26:04,620 --> 00:26:05,120
అయితే సరే.

612
00:26:05,120 --> 00:26:07,590
>> కాబట్టి యొక్క కొంత చర్చ తెలియజేయండి
యాక్సెస్ నమూనాలను గురించి బిట్.

613
00:26:07,590 --> 00:26:11,580
మేము NoSQL గురించి మాట్లాడేటప్పుడు, అంతే
అన్ని ప్రాప్యత నమూనా గురించి.

614
00:26:11,580 --> 00:26:13,550
ఇప్పుడు, SQL తదర్థ, ప్రశ్నలు ఉంది.

615
00:26:13,550 --> 00:26:14,481
ఇది రిలేషనల్ స్టోర్ ఉంది.

616
00:26:14,481 --> 00:26:16,480
మేము ఆందోళన లేదు
యాక్సెస్ నమూనా గురించి.

617
00:26:16,480 --> 00:26:17,688
నేను చాలా క్లిష్టమైన ప్రశ్న వ్రాయండి.

618
00:26:17,688 --> 00:26:19,250
చేజారిపోతుంది మరియు డేటా పొందుతాడు.

619
00:26:19,250 --> 00:26:21,210
ఈ కనిపిస్తోంది ఏమిటి
వంటి సాధారణీకరణ.

620
00:26:21,210 --> 00:26:24,890
>> ఈ ప్రత్యేక నిర్మాణం కాబట్టి
మేము ఒక ఉత్పత్తులు జాబితా చూడటం చేస్తున్నాం.

621
00:26:24,890 --> 00:26:26,640
నేను ఉత్పత్తులు వివిధ రకాల ఉన్నాయి.

622
00:26:26,640 --> 00:26:27,217
నేను పుస్తకాలు కలిగి.

623
00:26:27,217 --> 00:26:27,800
నేను ఆల్బమ్లు.

624
00:26:27,800 --> 00:26:30,090
నేను వీడియోలు ఉన్నాయి.

625
00:26:30,090 --> 00:26:33,370
ఉత్పత్తుల మధ్య సంబంధం
ఈ పుస్తకాలు, ఆల్బమ్లు ఏ ఒకటి,

626
00:26:33,370 --> 00:26:34,860
మరియు వీడియోలు పట్టికలు 1: 1.

627
00:26:34,860 --> 00:26:35,800
అయితే సరే?

628
00:26:35,800 --> 00:26:38,860
నేను ఒక ఉత్పత్తి ID పొందారు,
మరియు ఆ ID సదృశంగా

629
00:26:38,860 --> 00:26:41,080
ఒక పుస్తకం, ఒక ఆల్బమ్, లేదా ఒక వీడియో.

630
00:26:41,080 --> 00:26:41,580
అలాగే?

631
00:26:41,580 --> 00:26:44,350
1 సంబంధం: ఒక 1 ఉంది
ఆ పట్టికలు అంతటా.

632
00:26:44,350 --> 00:26:46,970
>> ఇప్పుడు వారందరు నవలలు
కలిగి రూట్ లక్షణాలు ఉంది.

633
00:26:46,970 --> 00:26:47,550
ఏమి ఇబ్బంది లేదు.

634
00:26:47,550 --> 00:26:48,230
ఆ గొప్ప పని.

635
00:26:48,230 --> 00:26:52,130
ఒకటి నుండి ఒకరికి సంబంధం, నేను అన్ని పొందుటకు
డేటా నేను ఆ పుస్తకం వర్ణించేందుకు అవసరం.

636
00:26:52,130 --> 00:26:54,770
Albums-- ఆల్బమ్లు ట్రాక్స్ కలిగి.

637
00:26:54,770 --> 00:26:56,470
ఈ మేము అనేక ఒక కాల్ ఏమిటి.

638
00:26:56,470 --> 00:26:58,905
ప్రతి ఆల్బమ్ అనేక ట్రాక్స్ కలిగి కాలేదు.

639
00:26:58,905 --> 00:27:00,780
ప్రతి ట్రాక్ను కాబట్టి
ఆల్బమ్ నేను కలిగి

640
00:27:00,780 --> 00:27:02,570
ఈ పిల్లల పట్టికలో మరో రికార్డు.

641
00:27:02,570 --> 00:27:04,680
నేను ఒక రికార్డు సృష్టించడానికి
నా ఆల్బమ్లు పట్టికలో.

642
00:27:04,680 --> 00:27:06,700
నేను బహుళ రికార్డులు సృష్టించడానికి
ట్రాక్స్ పట్టికలో.

643
00:27:06,700 --> 00:27:08,850
ఒకటి నుండి అనేక సంబంధాలు.

644
00:27:08,850 --> 00:27:11,220
>> ఈ సంబంధం ఏమిటి
మేము అనేక నుండి అనేక కాల్.

645
00:27:11,220 --> 00:27:11,750
అలాగే?

646
00:27:11,750 --> 00:27:17,000
మీరు నటులు కావచ్చు చూడండి
అనేక సినిమాలు, అనేక వీడియోలను లో.

647
00:27:17,000 --> 00:27:21,450
కాబట్టి మేము ఏమి మేము ఈ మాపింగ్ చాలు
ఆ మధ్య పట్టిక, ఇది కేవలం

648
00:27:21,450 --> 00:27:24,040
వీడియో ID నటుడు ID పటాలు.

649
00:27:24,040 --> 00:27:28,464
ఇప్పుడు నేను ది కలుస్తుంది ప్రశ్న సృష్టించవచ్చు
నటులు నటుడు వీడియో ద్వారా వీడియోలు,

650
00:27:28,464 --> 00:27:31,130
మరియు అది నాకు ఒక nice జాబితా ఇస్తుంది
అన్ని సినిమాలు మరియు అన్ని నటులు

651
00:27:31,130 --> 00:27:32,420
ఆ చిత్రం లో ఉన్నాయి.

652
00:27:32,420 --> 00:27:33,290
>> అలాగే.

653
00:27:33,290 --> 00:27:33,880
కాబట్టి ఇక్కడ వెళ్ళండి.

654
00:27:33,880 --> 00:27:38,040
ఒకటి నుండి ఒక ఉన్నత స్థాయి ఉంది
సంబంధాలు; ఒకటి నుండి అనేక

655
00:27:38,040 --> 00:27:40,240
ట్రాక్స్ ఆల్బమ్లు; అనేక నుండి అనేక.

656
00:27:40,240 --> 00:27:44,990
ఆ మూడు మొదటి స్థాయి ఉంటాయి
ఏ డేటాబేస్ లో సంబంధాలు.

657
00:27:44,990 --> 00:27:48,050
మీరు ఎలా ఆ తెలిస్తే
సంబంధాలు కలిసి పని,

658
00:27:48,050 --> 00:27:51,490
అప్పుడు మీరు చాలా తెలుసు
ఇప్పటికే డేటాబేస్ గురించి.

659
00:27:51,490 --> 00:27:55,660
కాబట్టి NoSQL భిన్నంగా కొద్దిగా పనిచేస్తుంది.

660
00:27:55,660 --> 00:27:58,930
యొక్క రెండవ కోసం గురించి ఆలోచించటం లెట్ అది
లుక్స్ నా ఉత్పత్తులు పొందండి వెళ్ళి ఇష్టం.

661
00:27:58,930 --> 00:28:01,096
>> ఒక రిలేషనల్ స్టోర్ లో, నేను
నా ఉత్పత్తులు పొందుటకు కావలసిన

662
00:28:01,096 --> 00:28:02,970
నా ఉత్పత్తులు జాబితాలో.

663
00:28:02,970 --> 00:28:04,910
అని ప్రశ్నలు చాలా ఉంది.

664
00:28:04,910 --> 00:28:07,030
నేను నా పుస్తకాల కోసం ఒక ప్రశ్న వచ్చింది.

665
00:28:07,030 --> 00:28:08,470
నా ఆల్బమ్లకు భిన్నంగా ప్రశ్న వచ్చింది.

666
00:28:08,470 --> 00:28:09,970
నేను నా వీడియోల కోసం ఒక ప్రశ్న వచ్చింది.

667
00:28:09,970 --> 00:28:11,719
మరియు నేను దానిని ఉంచాలి వచ్చింది
అన్ని కలిసి ఒక జాబితాలో

668
00:28:11,719 --> 00:28:15,250
మరియు తిరిగి అప్ సర్వ్
అడిగినవారికి ఆ అప్లికేషన్.

669
00:28:15,250 --> 00:28:18,000
>> నా పుస్తకాలు పొందడానికి, నేను చేరడానికి
ఉత్పత్తులు మరియు పుస్తకాలు.

670
00:28:18,000 --> 00:28:21,680
నా ఆల్బమ్లు పొందుటకు, నేను చేరడానికి వచ్చింది
ఉత్పత్తులు, ఆల్బమ్లు, మరియు ట్రాక్స్.

671
00:28:21,680 --> 00:28:25,330
నేను, నా వీడియోలను పొందడానికి
వీడియోలు ఉత్పత్తులు చేరడానికి,

672
00:28:25,330 --> 00:28:28,890
నటుడు వీడియోలు ద్వారా చేరడానికి,
అలాగే యాక్టర్ లో తీసుకుని.

673
00:28:28,890 --> 00:28:31,020
కాబట్టి ఆ మూడు ప్రశ్నలు వార్తలు.

674
00:28:31,020 --> 00:28:34,560
చాలా క్లిష్టమైన ప్రశ్నలు
ఒక ఫలితాల సమితి సిద్ధం.

675
00:28:34,560 --> 00:28:36,540
>> ఆ సరైన కంటే తక్కువగా.

676
00:28:36,540 --> 00:28:39,200
ఈ మేము మాట్లాడటానికి ఎందుకు ఉన్నప్పుడు
ఒక డేటా నిర్మాణం గురించి

677
00:28:39,200 --> 00:28:42,900
ప్రాప్తి చేయడానికి అజ్ఞేయ విధంగా నిర్మించబడింది
pattern-- గొప్ప అదే.

678
00:28:42,900 --> 00:28:45,730
మరియు మీరు ఈ నిజంగా చూడగలరు
మేము డేటా నిర్వహించాను బాగుంది.

679
00:28:45,730 --> 00:28:46,550
మరియు మీరు ఏమి?

680
00:28:46,550 --> 00:28:49,750
నేను మాత్రమే ఒక నటుడు కోసం ఒక రికార్డు ఉంది.

681
00:28:49,750 --> 00:28:50,440
>> చాలా బాగుంది.

682
00:28:50,440 --> 00:28:53,750
నేను నా నటులు deduplicated చేసిన,
మరియు నేను నా సంఘాలు నిర్వహించబడుతుంది

683
00:28:53,750 --> 00:28:55,200
ఈ మాపింగ్ పట్టికలో.

684
00:28:55,200 --> 00:29:00,620
అయితే, డేటా పొందడానికి
బయటకు ఖరీదైన అవుతుంది.

685
00:29:00,620 --> 00:29:04,500
నేను అన్ని సిస్టమ్ పైగా CPU పంపడం చేస్తున్నాను
కలిసి ఈ డేటా నిర్మాణాలు చేరిన

686
00:29:04,500 --> 00:29:05,950
ఆ డేటా తిరిగి లాగండి చెయ్యలేరు.

687
00:29:05,950 --> 00:29:07,310
>> సో ఎలా నేను ఆ చుట్టూ వస్తుందా?

688
00:29:07,310 --> 00:29:11,200
NoSQL లో అది గురించి
అగ్రిగేషన్, కాదు సాధారణీకరణ.

689
00:29:11,200 --> 00:29:13,534
సో మనం అనుకుందాం కావలసిన
యాక్సెస్ నమూనా మద్దతు.

690
00:29:13,534 --> 00:29:15,283
యాక్సెస్ నమూనా ఉంటే
అనువర్తనాలకు,

691
00:29:15,283 --> 00:29:16,770
నేను నా ఉత్పత్తులు పొందాలి.

692
00:29:16,770 --> 00:29:19,027
యొక్క ఒక పట్టిక లో అన్ని ఉత్పత్తులను చాలు లెట్.

693
00:29:19,027 --> 00:29:22,110
నేను ఒక పట్టిక లో అన్ని ఉత్పత్తులను ఉంచితే,
నేను అన్ని ఉత్పత్తులు ఎంచుకోవచ్చు

694
00:29:22,110 --> 00:29:23,850
పట్టిక నుండి మరియు నేను అన్ని పొందండి.

695
00:29:23,850 --> 00:29:25,240
సరే నేను ఆ చేయాలి?

696
00:29:25,240 --> 00:29:28,124
బాగా NoSQL ఏ ఉంది
పట్టిక నిర్మాణం.

697
00:29:28,124 --> 00:29:30,540
మేము గురించి కొద్దిగా చర్చ చేస్తాము
ఎలా ఈ డైనమో DB లో పనిచేస్తుంది.

698
00:29:30,540 --> 00:29:33,570
కానీ మీరు ఒకే లేదు
గుణాలు మరియు అదే లక్షణాలు

699
00:29:33,570 --> 00:29:37,751
ప్రతి ఒక్క ప్రతి ఒక్క వరుసగా
అంశం, మీరు ఒక SQL పట్టిక విధంగా.

700
00:29:37,751 --> 00:29:39,750
మరియు ఈ నాకు అనుమతిస్తుంది
చేయాలని విషయాలు చాలా ఉంది

701
00:29:39,750 --> 00:29:41,124
మరియు నాకు వశ్యత ఇచ్చాయి.

702
00:29:41,124 --> 00:29:45,360
ఈ ప్రత్యేక సందర్భంలో, నేను
నా ఉత్పత్తి పత్రాలు ఉన్నాయి.

703
00:29:45,360 --> 00:29:49,090
మరియు ఈ ముఖ్యంగా
ఉదాహరణకు, ప్రతిదీ

704
00:29:49,090 --> 00:29:51,930
ఉత్పత్తులు పట్టికలో ఒక పత్రం.

705
00:29:51,930 --> 00:29:56,510
మరియు ఒక పుస్తకం కోసం ఉత్పత్తి ఉండవచ్చు
ఒక పుస్తకం తెలుపు ఒక రకం ID కలిగి.

706
00:29:56,510 --> 00:29:59,180
మరియు అప్లికేషన్
ఆ ID పై పెడతారు.

707
00:29:59,180 --> 00:30:02,570
>> అప్లికేషన్ వరుస వద్ద, నేను వెళుతున్నాను
ఓహ్, ఈ ఏమి ఒక రికార్డు రకం చెప్పాలో?

708
00:30:02,570 --> 00:30:04,100
ఓహ్, ఇది ఒక పుస్తకం రికార్డు ఉంది.

709
00:30:04,100 --> 00:30:05,990
బుక్ రికార్డులు ఈ లక్షణాలు కలిగి.

710
00:30:05,990 --> 00:30:08,100
నాకు ఒక పుస్తకం వస్తువు సృష్టించడానికి లెట్.

711
00:30:08,100 --> 00:30:11,289
నేను పూరించడానికి వెళుతున్న
ఈ అంశాన్ని పుస్తకం వస్తువు.

712
00:30:11,289 --> 00:30:13,080
తదుపరి అంశం వచ్చి
ఈ అంశాన్ని ఏమిటి, చెప్పారు?

713
00:30:13,080 --> 00:30:14,560
ఈ అంశం ఒక ఆల్బమ్ ఉంది.

714
00:30:14,560 --> 00:30:17,340
ఓహ్, నేను మొత్తం వేరే వచ్చింది
ఆ కోసం ప్రాసెసింగ్ దినచర్య

715
00:30:17,340 --> 00:30:18,487
అది ఒక ఆల్బమ్ ఎందుకంటే.

716
00:30:18,487 --> 00:30:19,320
మీరు వాట్ ఐ మీన్ చూడండి?

717
00:30:19,320 --> 00:30:21,950
>> సో అప్లికేషన్ tier-- నేను
అన్ని ఈ రికార్డ్ ఎంచుకోండి.

718
00:30:21,950 --> 00:30:23,200
వారు అన్ని వస్తున్న మొదలు.

719
00:30:23,200 --> 00:30:24,680
వారు అన్ని వివిధ రకాల కావచ్చు.

720
00:30:24,680 --> 00:30:27,590
మరియు అది అప్లికేషన్ యొక్క తర్కం వార్తలు
ఆ రకాల అంతటా మారతాయి

721
00:30:27,590 --> 00:30:29,530
మరియు వాటిని ప్రాసెస్ ఎలా నిర్ణయిస్తుంది.

722
00:30:29,530 --> 00:30:33,640
>> మళ్ళీ, కాబట్టి మేము గరిష్టంగా చేస్తున్నారు
యాక్సెస్ నమూనా కొరకు స్కేమ.

723
00:30:33,640 --> 00:30:36,390
మేము ద్వారా చేయుచున్నారు
ఆ పట్టికలు కూలిపోయే.

724
00:30:36,390 --> 00:30:39,670
మేము ప్రధానంగా వేస్తున్నాము
ఈ సామాన్యీకరణ నిర్మాణాలు,

725
00:30:39,670 --> 00:30:42,000
మరియు మేము నిర్మించడం చేస్తున్నారు
క్రమానుగత నిర్మాణాలు.

726
00:30:42,000 --> 00:30:45,130
ఈ రికార్డ్ ప్రతి ఒకటి లోపల
నేను శ్రేణి లక్షణాలు చూడటానికి వెళుతున్న.

727
00:30:45,130 --> 00:30:49,400
>> ఆల్బమ్లు కోసం ఈ పత్రంలో,
నేను పాటలను శ్రేణుల చూసిన చేస్తున్నాను.

728
00:30:49,400 --> 00:30:53,900
ఆ పాటలు ఇప్పుడు అది become--
ప్రధానంగా ఈ పిల్లల పట్టిక

729
00:30:53,900 --> 00:30:56,520
ఇక్కడే ఈ నిర్మాణం ఉంది.

730
00:30:56,520 --> 00:30:57,975
కాబట్టి మీరు DynamoDB ఈ చేయవచ్చు.

731
00:30:57,975 --> 00:30:59,810
మీరు MongoDB ఈ చేయవచ్చు.

732
00:30:59,810 --> 00:31:01,437
మీరు ఏ NoSQL డేటాబేస్ లో చేయవచ్చు.

733
00:31:01,437 --> 00:31:03,520
ఈ రకమైన సృష్టించండి
క్రమానుగత డేటా నిర్మాణాలు

734
00:31:03,520 --> 00:31:07,120
మీరు డేటాను తిరిగి అనుమతించే
చాలా త్వరగా ఇప్పుడు ఎందుకంటే నేను

735
00:31:07,120 --> 00:31:08,537
అనుగుణంగా లేదు.

736
00:31:08,537 --> 00:31:11,620
నేను ట్రాక్ లోకి ఒక వరుసను ఇన్సర్ట్ చేసినప్పుడు
పట్టిక, లేదా ఆల్బమ్స్ పట్టికలో వరుసగా

737
00:31:11,620 --> 00:31:13,110
నేను ఆ స్కీమా అనుగుణంగా ఉంటుంది.

738
00:31:13,110 --> 00:31:18,060
నేను గుణం లేదా కలిగి
పట్టిక నిర్వచిస్తారు ఆస్తి.

739
00:31:18,060 --> 00:31:20,480
వాటిలో ప్రతి ఒక,
నేను ఆ వరుసలో ఇన్సర్ట్ ఉన్నప్పుడు.

740
00:31:20,480 --> 00:31:21,910
ఆ NoSQL విషయంలో కాదు.

741
00:31:21,910 --> 00:31:24,440
>> నేను విభిన్నమైన కలిగి
ప్రతి పత్రం లో లక్షణాలు

742
00:31:24,440 --> 00:31:26,100
నేను సేకరణ లోకి ఇన్సర్ట్.

743
00:31:26,100 --> 00:31:30,480
కాబట్టి చాలా శక్తివంతమైన విధానం.

744
00:31:30,480 --> 00:31:32,852
అది నిజంగా ఎలా మీరేనని
సిస్టమ్ ఆప్టిమైజ్.

745
00:31:32,852 --> 00:31:35,310
బదులుగా ఇప్పుడు ఆ ప్రశ్న, ఎందుకంటే
అన్ని టేబుళ్ళ చేరిన

746
00:31:35,310 --> 00:31:39,160
మరియు ఒక సగం ఒక డజను ప్రశ్నలు అమలు
నేను అవసరం డేటా తిరిగి లాగండి,

747
00:31:39,160 --> 00:31:40,890
నేను ఒక ప్రశ్న అమలు చేస్తున్నాను.

748
00:31:40,890 --> 00:31:43,010
నేను iterating ఉన్నాను
సెట్ ఫలితాలు అంతటా.

749
00:31:43,010 --> 00:31:46,512
మీరు ఒక ఆలోచన ఇస్తుంది
NoSQL యొక్క శక్తి.

750
00:31:46,512 --> 00:31:49,470
నేను రకమైన పక్కకి ఇక్కడ వెళ్ళండి వెళుతున్న
మరియు ఈ గురించి కొద్దిగా చర్చ.

751
00:31:49,470 --> 00:31:53,240
ఈ రకంగా ఉంది
మార్కెటింగ్ లేదా technology--

752
00:31:53,240 --> 00:31:55,660
టెక్నాలజీ మార్కెటింగ్
చర్చ రకం.

753
00:31:55,660 --> 00:31:58,672
కానీ అది అర్థం ముఖ్యం
మేము ఎగువన చూస్తే ఎందుకంటే

754
00:31:58,672 --> 00:32:00,380
ఇక్కడ ఈ పట్టికలో,
మనం వద్ద చూస్తున్న

755
00:32:00,380 --> 00:32:04,030
మేము కాల్ ఏమిటి
టెక్నాలజీ హైప్ వంగుతుంది.

756
00:32:04,030 --> 00:32:06,121
మరియు దీని అర్థం
క్రొత్త విషయాలను ఆటలోకి వస్తుంది.

757
00:32:06,121 --> 00:32:07,120
ప్రజలు ఇది గొప్ప అని.

758
00:32:07,120 --> 00:32:09,200
నేను నా సమస్యలు పరిష్కరించింది చేసిన.

759
00:32:09,200 --> 00:32:11,630
>> ఈ ముగింపు కావచ్చు
అన్ని, ప్రతిదీ అన్ని ఉంటుంది.

760
00:32:11,630 --> 00:32:12,790
మరియు వారు ఉపయోగించడం ప్రారంభించడానికి.

761
00:32:12,790 --> 00:32:14,720
మరియు వారు ఈ విషయాన్ని పని లేదు, చెప్పటానికి.

762
00:32:14,720 --> 00:32:17,600
ఈ కుడి కాదు.

763
00:32:17,600 --> 00:32:19,105
పాత విషయాలను బాగా ఉంది.

764
00:32:19,105 --> 00:32:21,230
మరియు వారు చేయడం తిరిగి వెళ్ళి
విషయాలు వారు మార్గం.

765
00:32:21,230 --> 00:32:22,730
తర్వాత చివరికి
వారు మీరు ఏమి, వెళ్ళాలి?

766
00:32:22,730 --> 00:32:24,040
ఈ విషయాన్ని అంత చెడ్డ కాదు.

767
00:32:24,040 --> 00:32:26,192
ఓహ్, అది ఎలా పనిచేస్తుంది.

768
00:32:26,192 --> 00:32:28,900
మరియు ఎలా వారు దాన్ని దొరుకుతుందని ఒకసారి
క్రియలు మెరుగుపడుతున్నాయి మొదలు.

769
00:32:28,900 --> 00:32:32,050
>> మరియు దాని గురించి ఫన్నీ విషయం
ఇది వరకు, రేఖల రకమైన ఏమిటి

770
00:32:32,050 --> 00:32:34,300
మేము టెక్నాలజీ అనుసరణ కర్వ్ కాల్.

771
00:32:34,300 --> 00:32:36,910
మనకిప్పుడు ఏమి జరుగుతుందనే
విధమైన సాంకేతికత ట్రిగ్గర్.

772
00:32:36,910 --> 00:32:39,100
డేటాబేస్ విషయంలో,
అది డేటా ఒత్తిడి ఉంది.

773
00:32:39,100 --> 00:32:42,200
మేము అధిక నీటి పాయింట్లు గురించి మాట్లాడారు
కాలక్రమంలో డేటా ఒత్తిడి.

774
00:32:42,200 --> 00:32:46,310
ఆ డేటా ఒత్తిడి ఒక నిర్దిష్ట తగిలినప్పుడు
పాయింట్, ఒక సాంకేతిక ట్రిగ్గర్ ఉంది.

775
00:32:46,310 --> 00:32:47,830
>> ఇది చాలా ఖరీదైన సంతరించుకోనుంది.

776
00:32:47,830 --> 00:32:49,790
ఇది డేటా ప్రాసెస్ చాలా పొడవుగా పడుతుంది.

777
00:32:49,790 --> 00:32:50,890
మేము మంచి ఏదో అవసరం.

778
00:32:50,890 --> 00:32:52,890
మీరు కల్పనా పొందండి
అక్కడ చుట్టూ నడుస్తున్న,

779
00:32:52,890 --> 00:32:55,050
పరిష్కారం ఏమి కనుగొనేందుకు ప్రయత్నిస్తున్న.

780
00:32:55,050 --> 00:32:56,050
కొత్త ఆలోచన ఏమిటి?

781
00:32:56,050 --> 00:32:58,170
>> ఉత్తమ తదుపరి ఏమిటి
ఈ విషయం అలా మార్గం?

782
00:32:58,170 --> 00:32:59,530
మరియు వారు ఏదో ఆలోచన.

783
00:32:59,530 --> 00:33:03,140
మరియు నిజమైన నొప్పి తో ప్రజలు,
రక్తస్రావం అంచు వద్ద అబ్బాయిలు,

784
00:33:03,140 --> 00:33:06,390
వారు అది జంప్ ఓవర్ చేస్తాము,
వారు ఒక సమాధానం అవసరం ఎందుకంటే.

785
00:33:06,390 --> 00:33:09,690
ఇప్పుడు అనివార్యంగా happens-- ఏమి మరియు
ఇది NoSQL ప్రస్తుతం జరుగుతున్నది.

786
00:33:09,690 --> 00:33:11,090
నేను అన్ని సమయం చూడండి.

787
00:33:11,090 --> 00:33:13,610
>> ఏం అనివార్యంగా జరుగుతుందనే
ప్రజలు కొత్త సాధనం ఉపయోగించడం ప్రారంభించడానికి

788
00:33:13,610 --> 00:33:15,490
అదే విధంగా వారు పాత సాధనం ఉపయోగించారు.

789
00:33:15,490 --> 00:33:17,854
మరియు వారు అది తెలుసుకోవడానికి
బాగా పని లేదు.

790
00:33:17,854 --> 00:33:20,020
నేను ఎవరు గుర్తులేకపోతే
ఈరోజు మాట్లాడటం.

791
00:33:20,020 --> 00:33:22,080
కానీ అది వంటిది
జాక్హామర్ కనుగొన్నారు,

792
00:33:22,080 --> 00:33:24,621
ప్రజలు దాని పై స్వింగ్ లేదు
వారి తల కాంక్రీటు కూలదోయగలదని.

793
00:33:24,621 --> 00:33:27,360

794
00:33:27,360 --> 00:33:30,610
>> కానీ ఆ ఏమిటి
నేడు NoSQL తో జరుగుతున్న.

795
00:33:30,610 --> 00:33:33,900
మీరు చాలా దుకాణాలకు లో నడవడానికి ఉంటే,
వారు NoSQL దుకాణాలు ప్రయత్నిస్తున్నారు.

796
00:33:33,900 --> 00:33:36,510
ఏమి చేస్తున్నామో ఉంది
వారు NoSQL ఉపయోగిస్తున్నట్లయితే

797
00:33:36,510 --> 00:33:39,900
మరియు వారు లోడ్ చేస్తున్నాము
రిలేషనల్ స్కీమా పూర్తి.

798
00:33:39,900 --> 00:33:41,630
ఆ ఎలా ఎందుకంటే
వారు డేటాబేస్ రూపకల్పన.

799
00:33:41,630 --> 00:33:44,046
మరియు వారు ఎందుకు వొండరింగ్ చేస్తున్న
ఇది చాలా బాగా ప్రదర్శించారు లేదు?

800
00:33:44,046 --> 00:33:45,230
బాయ్, ఈ విషయం stinks.

801
00:33:45,230 --> 00:33:49,900
నేను అన్ని నిర్వహించడానికి వచ్చింది నా
అది ఏ, ఏ, వంటిది in-- కలుస్తుంది.

802
00:33:49,900 --> 00:33:50,800
చేరతాడు నిర్వహించడానికి?

803
00:33:50,800 --> 00:33:52,430
ఎందుకు మీరు డేటా చేరుతుండటం?

804
00:33:52,430 --> 00:33:54,350
మీరు NoSQL డేటా చేరడానికి లేదు.

805
00:33:54,350 --> 00:33:55,850
మీరు అది సమగ్రం.

806
00:33:55,850 --> 00:34:00,690
>> మీరు ఈ నివారించడానికి అనుకుంటే, తెలుసుకోవడానికి కాబట్టి
సాధనం నిజానికి మీరు ముందు ఎలా పనిచేస్తుంది

807
00:34:00,690 --> 00:34:02,010
ఉపయోగించడం ప్రారంభించడానికి.

808
00:34:02,010 --> 00:34:04,860
ప్రయత్నించండి మరియు కొత్త టూల్స్ వాడకండి
అదే విధంగా మీరు పాత సాధనాలను ఉపయోగించాడు.

809
00:34:04,860 --> 00:34:06,500
మీరు ఒక చెడ్డ అనుభవం చూడాలని.

810
00:34:06,500 --> 00:34:08,848
మరియు ప్రతి ఒక్క సారి
ఈ గురించి ఏమిటి.

811
00:34:08,848 --> 00:34:11,389
మేము ఇక్కడ వస్తున్న ప్రారంభించినప్పుడు,
ప్రజలు కనుగొన్నారు ఎందుకంటే

812
00:34:11,389 --> 00:34:13,449
ఎలా టూల్స్ ఉపయోగించడానికి.

813
00:34:13,449 --> 00:34:16,250
>> వారు ఉన్నప్పుడు ఇదే చేశాడు
రిలేషనల్ డేటాబేస్ కనుగొన్నారు,

814
00:34:16,250 --> 00:34:17,969
మరియు వారు ఫైల్ వ్యవస్థలు స్థానంలో చేశారు.

815
00:34:17,969 --> 00:34:20,420
వారు ఫైల్ వ్యవస్థలు నిర్మించడానికి ప్రయత్నించారు
రిలేషనల్ డేటాబేస్ తో

816
00:34:20,420 --> 00:34:22,159
ప్రజలు అర్థం ఏమి ఎందుకంటే.

817
00:34:22,159 --> 00:34:23,049
అది పని చేయలేదు.

818
00:34:23,049 --> 00:34:26,090
ఉత్తమ విధానాలను అర్థం చేసుకోవడం
టెక్నాలజీ మీరు పనిచేస్తున్న

819
00:34:26,090 --> 00:34:26,730
భారీ ఉంది.

820
00:34:26,730 --> 00:34:29,870
చాలా ముఖ్యము.

821
00:34:29,870 --> 00:34:32,440
>> కాబట్టి మేము DynamoDB పొందడానికి వెళుతున్న.

822
00:34:32,440 --> 00:34:36,480
DynamoDB AWS యొక్క ఉంది
NoSQL వేదిక పూర్తిగా నిర్వహించేది.

823
00:34:36,480 --> 00:34:37,719
అర్థం ఏమి పూర్తిగా నిర్వహించేది లేదు?

824
00:34:37,719 --> 00:34:40,010
ఇది మీరు అవసరం లేదు అంటే
నిజంగా ఏదైనా గురించి ఆందోళన.

825
00:34:40,010 --> 00:34:42,060
>> మీరు వచ్చి మీరు చెప్పండి
మాకు, నేను ఒక పట్టిక అవసరం.

826
00:34:42,060 --> 00:34:43,409
ఇది ఈ చాలా సామర్థ్యం అవసరం.

827
00:34:43,409 --> 00:34:47,300
మీరు బటన్ నొక్కండి మరియు మేము సదుపాయం
సన్నివేశం వెనుక అన్ని అవస్థాపన.

828
00:34:47,300 --> 00:34:48,310
ఇప్పుడు ఆ అపారమైన ఉంది.

829
00:34:48,310 --> 00:34:51,310
>> మీరు మాట్లాడే ఎందుకంటే
ఒక డేటాబేస్ స్కేలింగ్ గురించి

830
00:34:51,310 --> 00:34:53,917
NoSQL డేటా సమూహాలు
స్థాయి, నడుస్తున్న petabytes,

831
00:34:53,917 --> 00:34:55,750
లక్షలాది నడుస్తున్న
సెకనుకు లావాదేవీలు,

832
00:34:55,750 --> 00:34:58,180
ఈ విషయాలు గుత్తులుగా కాదు.

833
00:34:58,180 --> 00:35:00,830
మేము సందర్భాల్లో వేల మాట్లాడటం చేస్తున్నారు.

834
00:35:00,830 --> 00:35:04,480
ఉదాహరణలలో వేల మేనేజింగ్,
కూడా వాస్తవిక సందర్భాలు

835
00:35:04,480 --> 00:35:06,350
బట్ లో ఒక నిజమైన నొప్పి ఉంటుంది.

836
00:35:06,350 --> 00:35:09,110
నేను ప్రతిసారీ గురించి ఆలోచించడం అర్థం
ఆపరేటింగ్ సిస్టమ్ పాచ్ బయటకు వస్తుంది

837
00:35:09,110 --> 00:35:11,552
లేదా డేటాబేస్ యొక్క ఒక కొత్త వెర్షన్.

838
00:35:11,552 --> 00:35:13,260
ఆ అర్థం ఏమిటి
మీరు క్రియాత్మకంగా?

839
00:35:13,260 --> 00:35:16,330
మీరు 1,200 వచ్చింది అర్థం
అవసరమైన సర్వర్లు నవీకరించబడింది వుంటుంది.

840
00:35:16,330 --> 00:35:18,960
ఇప్పుడు కూడా ఆటోమేషన్ తో,
ఆ కాలం పట్టవచ్చు.

841
00:35:18,960 --> 00:35:21,480
ఆ చాలా కారణమవుతుంది
కార్యాచరణ తలనొప్పి,

842
00:35:21,480 --> 00:35:23,090
నేను సేవలు డౌన్ కలిగి ఉండవచ్చు ఎందుకంటే.

843
00:35:23,090 --> 00:35:26,070
>> నేను ఈ డేటాబేస్ అప్డేట్ వంటి, నేను
నీలం, ఆకుపచ్చ మోహరింపుకు చేయండి ఉండవచ్చు

844
00:35:26,070 --> 00:35:29,420
నేను ఎక్కడ విస్తరించడానికి మరియు అప్గ్రేడ్ సగం నా
శోషగ్రంధులు, మరియు అప్పుడు మిగిలిన సగం అప్గ్రేడ్.

845
00:35:29,420 --> 00:35:30,490
తగ్గుముఖం పడుతుంది.

846
00:35:30,490 --> 00:35:33,410
కాబట్టి మౌలిక మేనేజింగ్
స్థాయి ఎంతో బాధాకరం.

847
00:35:33,410 --> 00:35:36,210
మరియు AWS అది బయటకు నొప్పి పడుతుంది.

848
00:35:36,210 --> 00:35:39,210
మరియు NoSQL డేటాబేస్ చెయ్యవచ్చు
అసాధారణమైన బాధాకరంగా ఉంటుంది

849
00:35:39,210 --> 00:35:41,780
వారు స్కేల్ మార్గం ఎందుకంటే.

850
00:35:41,780 --> 00:35:42,926
>> అడ్డంగా కొలమానము.

851
00:35:42,926 --> 00:35:45,550
మీరు ఒక పెద్ద NoSQL పొందడానికి అనుకుంటే
డేటాబేస్, మీరు మరింత నోడ్స్ కొనుగోలు.

852
00:35:45,550 --> 00:35:48,660
మీరు కొనుగోలు ప్రతి కణుపు
మరొక పనిచేస్తున్న తలనొప్పి.

853
00:35:48,660 --> 00:35:50,830
కాబట్టి మరొకరిని మీరు ఆ తెలియజేసేలా.

854
00:35:50,830 --> 00:35:52,000
AWS ఆ చేయవచ్చు.

855
00:35:52,000 --> 00:35:54,587
>> మేము పత్రం కీ విలువలకు మద్దతు.

856
00:35:54,587 --> 00:35:56,670
ఇప్పుడు మేము చాలా వెళ్ళలేదు
ఇతర చార్టులో లోకి.

857
00:35:56,670 --> 00:35:58,750
వివిధ చాలా ఉంది
NoSQL రుచులు.

858
00:35:58,750 --> 00:36:02,670
వారు పొందడానికి అన్ని రకమైన ఉన్నారు
ఈ సమయంలో కలిసి munged.

859
00:36:02,670 --> 00:36:06,260
మీరు DynamoDB చూడండి మరియు అవును చెప్పగలను
మేము ఒక పత్రం మరియు ఒక కీ విలువ రెండు ఉన్నాము

860
00:36:06,260 --> 00:36:08,412
ఈ సమయంలో నిల్వ.

861
00:36:08,412 --> 00:36:10,620
మరియు మీరు లక్షణాలను వాదిస్తారు చేయవచ్చు
ఇతర మీద ఒక యొక్క.

862
00:36:10,620 --> 00:36:13,950
నాకు, ఈ చాలా నిజంగా ఆరు
సగం ఇతర యొక్క డజను.

863
00:36:13,950 --> 00:36:18,710
ఈ సాంకేతికతలు ప్రతి ఒకటి ఒక
జరిమానా సాంకేతికత మరియు జరిమానా పరిష్కారం.

864
00:36:18,710 --> 00:36:23,390
నేను MongoDB మంచి లేదా అని చెబుతారు కాదు
అప్పుడు మంచం, కాసాండ్రా కంటే దారుణంగా

865
00:36:23,390 --> 00:36:25,994
అప్పుడు డైనమో, లేదా ఇదే విధంగా విరుద్ధంగా.

866
00:36:25,994 --> 00:36:27,285
నేను ఈ కేవలం ఐచ్చికములు, అర్థం.

867
00:36:27,285 --> 00:36:29,850

868
00:36:29,850 --> 00:36:32,700
>> ఇది వేగవంతమైనది మరియు అంతే
ఏ స్థాయిలో వద్ద స్థిరంగా.

869
00:36:32,700 --> 00:36:36,210
కాబట్టి ఈ అతిపెద్ద ఒకటి
బోనస్లు మీరు AWS తో పొందండి.

870
00:36:36,210 --> 00:36:40,850
DynamoDB తో సామర్ధ్యం
తక్కువ అంకె పొందడానికి

871
00:36:40,850 --> 00:36:44,040
ఏ స్థాయిలో మిల్లిసెకనులో అంతర్గతాన్ని.

872
00:36:44,040 --> 00:36:45,720
ఆ వ్యవస్థ యొక్క ఒక నమూనా గోల్.

873
00:36:45,720 --> 00:36:49,130
మరియు మేము చేస్తున్న ఆ వినియోగదారులు కలిగి
సెకనుకు లావాదేవీల మిలియన్ల.

874
00:36:49,130 --> 00:36:52,670
>> ఇప్పుడు నేను ఆ కొన్ని ద్వారా వెళ్తారో
ఇక్కడ కొన్ని నిమిషాల్లో సందర్భాల్లో ఉపయోగం.

875
00:36:52,670 --> 00:36:55,660
ఇంటిగ్రేటెడ్ యాక్సెస్ control--
మేము కాల్ ఏమి కలిగి

876
00:36:55,660 --> 00:36:57,920
గుర్తింపు ఆస్తుల నిర్వహణ, లేదా IAM.

877
00:36:57,920 --> 00:37:01,980
ఇది ప్రతి వ్యవస్థ విస్తరిస్తుంది,
AWS అందిస్తుంది ప్రతి సేవ.

878
00:37:01,980 --> 00:37:03,630
DynamoDB మినహాయింపు కాదు.

879
00:37:03,630 --> 00:37:06,020
మీరు యాక్సెస్ నియంత్రించవచ్చు
DynamoDB పట్టికలు.

880
00:37:06,020 --> 00:37:09,960
మీ AWS ద్వారా ఖాతాల అంతటా
ప్రాప్తి అనుమతులు నిర్వచించు

881
00:37:09,960 --> 00:37:12,140
IAM అవస్థాపనా.

882
00:37:12,140 --> 00:37:16,630
>> మరియు అది ఒక కీ మరియు అంతర్భాగం వార్తలు
మేము రూపు ప్రోగ్రామింగ్ ఈవెంట్ కాల్ ఏమి.

883
00:37:16,630 --> 00:37:19,056
ఇప్పుడు ఈ ఒక నూతన రూపావళి ఉంది.

884
00:37:19,056 --> 00:37:22,080
>> ప్రేక్షకులు: ఎలా నిజమైన మీ రేటు వార్తలు
తప్పుడు ప్రతికూలతలు వర్సెస్ పాజిటివ్

885
00:37:22,080 --> 00:37:24,052
మీ యాక్సెస్ కంట్రోల్ సిస్టమ్ లో?

886
00:37:24,052 --> 00:37:26,260
రిక్ HOULIHAN: ట్రూ పాజిటివ్
తప్పుడు ప్రతికూలతలు వర్సెస్?

887
00:37:26,260 --> 00:37:28,785
ప్రేక్షకులు: ఏమి రిటర్నింగ్
మీరు తిరిగి చేయాలి?

888
00:37:28,785 --> 00:37:33,720
ఒక సమయంలో వ్యతిరేకంగా
దీన్ని సరిదిద్దడంలో చేయాలి ఉన్నప్పుడు తిరిగి లేదు?

889
00:37:33,720 --> 00:37:36,260

890
00:37:36,260 --> 00:37:38,050
>> రిక్ HOULIHAN: నేను మీరు చెప్పండి కాలేదు.

891
00:37:38,050 --> 00:37:40,140
ఏ వైఫల్యాలు ఉంది ఉంటే
లేనే ఆ పైన,

892
00:37:40,140 --> 00:37:42,726
నేను గోవా వ్యక్తి కాదు
నిర్దిష్ట ప్రశ్న.

893
00:37:42,726 --> 00:37:43,850
కానీ ఒక మంచి ప్రశ్న.

894
00:37:43,850 --> 00:37:45,905
తెలుసు నేను ఆసక్తికరమైన ఉంటుంది
నాకు ఆ, నిజానికి.

895
00:37:45,905 --> 00:37:48,810

896
00:37:48,810 --> 00:37:51,320
>> కాబట్టి అప్పుడు మళ్ళీ, నూతన రూపావళి
ఈవెంట్ నడిచే ప్రోగ్రామింగ్ ఉంది.

897
00:37:51,320 --> 00:37:55,160
ఈ మీరు చెయ్యవచ్చు ఆలోచన
సంక్లిష్ట అనువర్తనాల్లో విస్తరించాలో ఆ

898
00:37:55,160 --> 00:37:59,720
చాలా, చాలా అధిక స్థాయి నిర్వహించగల
ఏ మౌలిక సదుపాయాలు లేకుండా.

899
00:37:59,720 --> 00:38:02,120
ఏ స్థిర లేకుండా
లేనే అవస్థాపన.

900
00:38:02,120 --> 00:38:04,720
మరియు మేము కొద్దిగా మాట్లాడండి చేస్తాము
మేము వంటి అర్థం గురించి

901
00:38:04,720 --> 00:38:06,550
పటాలు తదుపరి రెండు లో పొందండి.

902
00:38:06,550 --> 00:38:08,716
>> మేము చేస్తాము మొదటి విషయం
మేము పట్టికలు గురించి మాట్లాడండి చేస్తాము ఉంది.

903
00:38:08,716 --> 00:38:10,857
డైనమో కోసం API డేటా రకాల.

904
00:38:10,857 --> 00:38:13,190
మొదటి విషయం మరియు మీరు చేస్తాము
మీరు ఈ చూడండి గమనించవచ్చు,

905
00:38:13,190 --> 00:38:17,930
మీరు ఏ డేటాబేస్ తెలిసి ఉంటే,
డేటాబేస్ API లు నిజంగా రెండు రకమైన కలిగి

906
00:38:17,930 --> 00:38:18,430
నేను కాల్ ఇష్టం.

907
00:38:18,430 --> 00:38:21,570
లేదా API రెండు సెట్లు.

908
00:38:21,570 --> 00:38:23,840
ఆ ఒకటి ఉంటుంది
పరిపాలనా API.

909
00:38:23,840 --> 00:38:26,710
>> వారు జాగ్రత్తగా పడుతుంది విషయాలు
డేటాబేస్ విధులు.

910
00:38:26,710 --> 00:38:31,340
నిల్వ ఇంజిన్ ఆకృతీకరించుట
ఏర్పాటు మరియు పట్టికలు జోడించడం.

911
00:38:31,340 --> 00:38:35,180
సృష్టించడంలో డేటాబేస్
విభాగాలలోని మరియు చోట్ల.

912
00:38:35,180 --> 00:38:40,450
DynamoDB ఈ విషయాలు, మీరు
చాలా చిన్న, చిన్న జాబితాలను కలిగి.

913
00:38:40,450 --> 00:38:43,120
>> కాబట్టి ఇతర డేటాబేస్ లో,
మీరు కొద్దీ చూడవచ్చు

914
00:38:43,120 --> 00:38:45,680
పరిపాలనా యొక్క, ఆదేశాలు
ఆదేశాలు, ఆకృతీకరించటానికి

915
00:38:45,680 --> 00:38:47,290
ఈ అదనపు ఎంపికలు.

916
00:38:47,290 --> 00:38:51,234
DynamoDB లో మీరు ఎందుకంటే ఆ అవసరం లేదు
మీరు సిస్టమ్ కాన్ఫిగర్ లేదు, మేము.

917
00:38:51,234 --> 00:38:54,150
కాబట్టి మీరు చెయ్యాల్సిన మాత్రమే విషయం
నేను అవసరం ఏమి పరిమాణ టేబుల్ చెప్పు.

918
00:38:54,150 --> 00:38:55,660
కాబట్టి మీరు చాలా పొందుటకు
ఆదేశాల పరిమిత సమితి.

919
00:38:55,660 --> 00:38:58,618
>> మీరు ఒక టేబుల్ అప్డేట్ సృష్టించు పొందుటకు, టేబుల్,
టేబుల్ తొలగించు, మరియు టేబుల్ వివరించండి.

920
00:38:58,618 --> 00:39:01,150
ఆ మాత్రమే విషయాలు
మీరు DynamoDB కోసం అవసరం.

921
00:39:01,150 --> 00:39:03,294
మీరు ఒక నిల్వ అవసరం లేదు
ఇంజిన్ కాన్ఫిగరేషన్.

922
00:39:03,294 --> 00:39:04,960
నేను ప్రతికృతి గురించి ఆందోళన అవసరం లేదు.

923
00:39:04,960 --> 00:39:06,490
నేను sharding గురించి ఆందోళన అవసరం లేదు.

924
00:39:06,490 --> 00:39:07,800
>> నేను ఆందోళన అవసరం లేదు
ఈ విషయాన్ని గురించి.

925
00:39:07,800 --> 00:39:08,740
మేము మీరు కోసం అన్ని చేస్తాను.

926
00:39:08,740 --> 00:39:11,867
కాబట్టి ఆ భారాన్ని ఒక పెద్ద మొత్తం ఉంది
కేవలం మీ పళ్ళెంలో ఎత్తివేసింది ఉంది.

927
00:39:11,867 --> 00:39:13,200
అప్పుడు మేము CRUD ఆపరేటర్లు కలిగి.

928
00:39:13,200 --> 00:39:17,740
CRUD ఏదో మనం ఉంది
ఆ డేటాబేస్ లో కాల్

929
00:39:17,740 --> 00:39:19,860
నవీకరణ ఆపరేటర్లు తొలగించు సృష్టించండి.

930
00:39:19,860 --> 00:39:24,180
ఇవి మీ సాధారణం
డేటాబేస్ కార్యకలాపాలు.

931
00:39:24,180 --> 00:39:31,299
పుట్ అంశం వంటి విషయాలను, అంశం, నవీకరణ పొందడానికి
అంశాలు, తొలగించండి బ్యాచ్ ప్రశ్న, స్కాన్.

932
00:39:31,299 --> 00:39:32,840
మీరు మొత్తం పట్టిక స్కాన్ కోరుకుంటే.

933
00:39:32,840 --> 00:39:34,220
పట్టిక ఆఫ్ ప్రతిదీ లాగండి.

934
00:39:34,220 --> 00:39:37,130
DynamoDB గురించి nice విషయాలు ఒకటి
ఇది సమాంతర స్కానింగ్ అనుమతిస్తుంది.

935
00:39:37,130 --> 00:39:40,602
కాబట్టి మీరు నిజంగా ఎన్ని నాకు తెలియజేయండి
థ్రెడ్లు మీరు ఆ స్కాన్ అమలు కావలసిన.

936
00:39:40,602 --> 00:39:41,810
మరియు మేము ఆ దారాలను అమలు చెయ్యవచ్చు.

937
00:39:41,810 --> 00:39:43,985
మేము ఆ స్కాన్ స్పిన్ చేయవచ్చు
బహుళ తంతుల అంతటా

938
00:39:43,985 --> 00:39:49,060
కాబట్టి మీరు మొత్తం పట్టిక స్కాన్ చేయవచ్చు
చాలా, చాలా త్వరగా DynamoDB లో స్పేస్.

939
00:39:49,060 --> 00:39:51,490
>> మేము కలిగి ఇతర API ఉంది
మేము మా Streams API కాల్ ఏమి.

940
00:39:51,490 --> 00:39:52,940
మేము చాలా మాట్లాడటానికి వెళ్ళడం లేదు చేస్తున్నాం
ప్రస్తుతం శర్మలకు.

941
00:39:52,940 --> 00:39:55,189
నేను కొన్ని కంటెంట్ తరువాత పొందారు
ఈ గురించి డెక్ లో.

942
00:39:55,189 --> 00:39:59,910
కానీ Streams నిజంగా ఒక running-- ఉంది
సమయం ఆదేశించిన విధంగా ఆలోచించి

943
00:39:59,910 --> 00:40:01,274
విభజనను మార్పు లాగ్.

944
00:40:01,274 --> 00:40:03,940
జరుగుతున్నది అంతా
పట్టిక స్ట్రీమ్లో అప్ చూపిస్తుంది.

945
00:40:03,940 --> 00:40:05,940
>> ప్రతి పట్టిక వ్రాయండి
స్ట్రీమ్లో అప్ చూపిస్తుంది.

946
00:40:05,940 --> 00:40:08,370
మీరు ఆ స్ట్రీమ్ చదువుకోవచ్చు, మరియు
మీరు తో చేయవచ్చు.

947
00:40:08,370 --> 00:40:10,150
మేము గురించి మాట్లాడండి చేస్తాము ఏమి
విషయాలు రకాల మీరు

948
00:40:10,150 --> 00:40:13,680
ప్రతికృతి వంటి విషయాల్లో చేయండి,
ద్వితీయ సూచికలు సృష్టించడం.

949
00:40:13,680 --> 00:40:17,620
నిజంగా చల్లని అన్ని రకాల
విషయాలు మీరు ఆ తో చేయవచ్చు.

950
00:40:17,620 --> 00:40:19,150
>> సమాచార రకాలు.

951
00:40:19,150 --> 00:40:23,320
DynamoDB, మేము రెండు కీ మద్దతు
విలువ మరియు పత్రం డేటా రకాల.

952
00:40:23,320 --> 00:40:26,350
స్క్రీన్ ఎడమ వైపు
ఇక్కడ, మేము మా ప్రాథమిక రకాల పొందారు.

953
00:40:26,350 --> 00:40:27,230
కీ విలువ రకాల.

954
00:40:27,230 --> 00:40:30,040
ఈ తీగలు ఉంటాయి,
సంఖ్యలు, మరియు బైనరీలు.

955
00:40:30,040 --> 00:40:31,640
>> కాబట్టి కేవలం మూడు ప్రాథమిక రకాలు.

956
00:40:31,640 --> 00:40:33,700
ఆపై మీరు ఆ సెట్లు కలిగి ఉంటుంది.

957
00:40:33,700 --> 00:40:37,650
Nice విషయాలు ఒకటి NoSQL గురించి
మీరు లక్షణాలు వంటి శ్రేణుల వుండవచ్చు.

958
00:40:37,650 --> 00:40:42,050
మరియు DynamoDB మీకు శ్రేణుల ఇరవయి
ఒక రూట్ ఆస్తిగా ప్రాథమిక రకాల.

959
00:40:42,050 --> 00:40:43,885
>> ఆపై పత్రం రకాల ఉంది.

960
00:40:43,885 --> 00:40:45,510
ఎంత మంది JSON తెలిసిన?

961
00:40:45,510 --> 00:40:47,130
చాలా JSON తెలిసిన మీరు అబ్బాయిలు?

962
00:40:47,130 --> 00:40:49,380
ఇది ప్రాథమికంగా JavaScript ఉంది
ఆబ్జెక్ట్ నొటేషన్.

963
00:40:49,380 --> 00:40:52,510
అది మీరు basically అనుమతిస్తుంది
తరతమ శ్రేణి నిర్మాణంలో వివరిస్తాయి.

964
00:40:52,510 --> 00:40:58,107
>> మీరు ఒక JSON పత్రం నిల్వ చేయవచ్చు
DynamoDB సాధారణ భాగాలు ఉపయోగించి

965
00:40:58,107 --> 00:41:00,940
లేదా ఆ బిల్డింగ్ బ్లాక్స్ అందుబాటులో ఉన్నాయి
చాలా ప్రోగ్రామింగ్ భాషల్లో.

966
00:41:00,940 --> 00:41:03,602
మీరు జావా కలిగి ఉంటే, మీరు
పటాలు మరియు జాబితాలు చూడటం.

967
00:41:03,602 --> 00:41:05,060
నేను ఆ ప్రాంతంలో మ్యాప్ వస్తువులు సృష్టించవచ్చు.

968
00:41:05,060 --> 00:41:08,030
కీ విలువలు పటం
లక్షణాలు వంటి నిల్వ.

969
00:41:08,030 --> 00:41:10,890
మరియు అది యొక్క జాబితాలను కలిగి ఉండవచ్చు
ఆయా ధర్మాలకు లోపల విలువలు.

970
00:41:10,890 --> 00:41:13,490
మీరు ఈ క్లిష్టమైన నిల్వ చేయవచ్చు
తరతమ శ్రేణి నిర్మాణంలో

971
00:41:13,490 --> 00:41:16,320
ఒకే గుణాన్ని
ఒక DynamoDB అంశం.

972
00:41:16,320 --> 00:41:19,010

973
00:41:19,010 --> 00:41:24,460
>> DynamoDB పట్టికలు కాబట్టి, చాలా వంటి
NoSQL డేటాబేస్, పట్టికలు అంశాలను కలిగి.

974
00:41:24,460 --> 00:41:26,469
MongoDB లో మీరు చేస్తాను
ఈ పత్రాలు కాల్.

975
00:41:26,469 --> 00:41:27,760
మరియు అది మంచం బేస్ ఉంటుంది.

976
00:41:27,760 --> 00:41:28,900
కూడా ఒక పత్రం డేటాబేస్.

977
00:41:28,900 --> 00:41:29,941
ఈ పత్రాలలో కాల్.

978
00:41:29,941 --> 00:41:32,930
పత్రాలు లేదా వస్తువులను లక్షణాలను కలిగి.

979
00:41:32,930 --> 00:41:35,850
గుణాలు ఉన్నాయనే లేదా
అంశంపై ఉనికిలో.

980
00:41:35,850 --> 00:41:38,520
DynamoDB లో ఉంది
ఒక తప్పనిసరి గుణం.

981
00:41:38,520 --> 00:41:43,880
జస్ట్ ఒక రిలేషనల్ డేటాబేస్ లో ఇష్టం,
మీరు పట్టిక ప్రాథమిక కీ కలిగి.

982
00:41:43,880 --> 00:41:46,010
>> DynamoDB మేము ఒక హాష్ కీ కాల్ ఏమి కలిగి ఉంది.

983
00:41:46,010 --> 00:41:48,280
హాష్ కీ ప్రత్యేకంగా ఉండాలి.

984
00:41:48,280 --> 00:41:52,580
నేను ఒక హాష్ పట్టిక వివరిస్తాయి,
ప్రధానంగా నేను చెప్పడం నేను

985
00:41:52,580 --> 00:41:54,110
ప్రతి అంశం ఒక హాష్ కీ ఉంటుంది ఉంది.

986
00:41:54,110 --> 00:41:58,520
మరియు ప్రతి హాష్ కీ ప్రత్యేకంగా ఉండాలి.

987
00:41:58,520 --> 00:42:01,200
>> ప్రతి అంశం నిర్వచిస్తారు
ఆ ఏకైక హాష్ కీ ద్వారా.

988
00:42:01,200 --> 00:42:02,940
మరియు మాత్రమే ఒక ఉంటుంది.

989
00:42:02,940 --> 00:42:05,820
ఈ OK, కానీ తరచు
ప్రజలు ఏమి అవసరం

990
00:42:05,820 --> 00:42:08,170
వారు కోరుతున్నది ఈ హాష్ ఉంది
మరింత కొద్దిగా కీ

991
00:42:08,170 --> 00:42:11,010
కంటే కేవలం ఒక ఏకైక గుర్తింపు ఉంటుంది.

992
00:42:11,010 --> 00:42:15,240
తరచుగా మేము హాష్ కీ ఉపయోగించడానికి అనుకుంటే
ఉన్నత స్థాయిలో అగ్రిగేషన్ బకెట్ వంటి.

993
00:42:15,240 --> 00:42:19,160
మరియు మేము అలా మార్గం ద్వారా
మేము ఒక పరిధి కీ కాల్ ఏమి జోడించడం.

994
00:42:19,160 --> 00:42:22,460
>> అది మాత్రమే ఒక హాష్ చేస్తే
పట్టిక, ఈ ప్రత్యేకంగా ఉండాలి.

995
00:42:22,460 --> 00:42:27,040
అది ఒక హాష్ మరియు పరిధి పట్టిక ఉంటే,
హాష్ మరియు పరిధి కలయిక

996
00:42:27,040 --> 00:42:28,640
ప్రత్యేకంగా ఉండాలి.

997
00:42:28,640 --> 00:42:30,110
కాబట్టి ఈ విధంగా దాని గురించి ఆలోచించటం.

998
00:42:30,110 --> 00:42:32,140
నేను ఒక ఫోరమ్ కలిగి ఉంటే.

999
00:42:32,140 --> 00:42:39,010
మరియు రూపం అది కలిగి విషయాలకు ఉంది
పోస్ట్లు మరియు అది స్పందనలు ఉంది.

1000
00:42:39,010 --> 00:42:42,630
>> నేను ఒక హాష్ కలిగి ఉండవచ్చు
టాపిక్ ID ఇది కీ.

1001
00:42:42,630 --> 00:42:46,650
నేను ఒక శ్రేణి కీ కలిగి ఉండవచ్చు,
దానికి ప్రతి స్పందన ID.

1002
00:42:46,650 --> 00:42:49,650
ఆ విధంగా నేను అన్ని పొందుటకు కావాలా
ప్రత్యేక అంశం కోసం స్పందనలు,

1003
00:42:49,650 --> 00:42:52,370
నేను హాష్ ప్రశ్నించడానికి.

1004
00:42:52,370 --> 00:42:55,190
నేను అన్ని ఇవ్వాలని చెప్పేవాడిని చేయవచ్చు
ఈ హాష్ కలిగి అంశాలు.

1005
00:42:55,190 --> 00:43:01,910
మరియు నేను ప్రతి ప్రశ్నకు పొందడానికి వెళుతున్న
లేదా ఆ ఫలానా విషయం పోస్ట్.

1006
00:43:01,910 --> 00:43:03,910
ఈ ఉన్నత స్థాయిలో aggregations
చాలా ముఖ్యమైనవి.

1007
00:43:03,910 --> 00:43:07,370
వారు ప్రాథమిక ప్రవేశ మద్దతు
అప్లికేషన్ యొక్క నమూనా.

1008
00:43:07,370 --> 00:43:09,420
సాధారణంగా, ఈ మాట్లాడే
మేము చేయాలనుకుంటున్నారా ఏమిటి.

1009
00:43:09,420 --> 00:43:11,780
మేము ఆ పట్టిక కావలసిన
మీరు పట్టిక లోడ్ వంటి,

1010
00:43:11,780 --> 00:43:16,640
మేము డేటా ఏర్పరచుకునే కావలసిన
విధంగా పట్టిక లోపల

1011
00:43:16,640 --> 00:43:20,140
ఆ అప్లికేషన్ చాలా చెయ్యవచ్చు
త్వరగా ఆ ఫలితాలను పొందడానికి.

1012
00:43:20,140 --> 00:43:24,510
మరియు తరచు అలా మార్గం
మేము ఈ aggregations నిర్వహించడానికి

1013
00:43:24,510 --> 00:43:25,650
డేటా ఇన్సర్ట్.

1014
00:43:25,650 --> 00:43:31,110
సాధారణంగా, మేము డేటా వ్యాప్తి చేస్తున్నారు
ప్రకాశవంతమైన బకెట్ లోకి వస్తుంది.

1015
00:43:31,110 --> 00:43:35,210
>> రేంజ్ కీలను నాకు హాష్ అనుమతిస్తుంది
కీలు సమానత్వం ఉండాలి.

1016
00:43:35,210 --> 00:43:39,490
నేను ఒక హాష్ ప్రశ్నించడానికి చేసినప్పుడు, నేను చెప్పేది
నాకు ఈ సమానం ఒక హాష్ ఇస్తాయి.

1017
00:43:39,490 --> 00:43:41,950
నేను ఒక పరిధి ప్రశ్నించడానికి, నేను
నాకు ఒక శ్రేణి ఇస్తుంది చెప్పగలను

1018
00:43:41,950 --> 00:43:47,040
ఏ రకమైన ఉపయోగిస్తోంది
మేము మద్దతు గొప్ప ఆపరేటర్లు.

1019
00:43:47,040 --> 00:43:49,200
నాకు హాష్ కోసం అన్ని అంశాలను ఇవ్వండి.

1020
00:43:49,200 --> 00:43:52,520
అది కంటే ఎక్కువ, సమానం
ఇది ప్రారంభమవుతాయి లేదు, కంటే తక్కువ,

1021
00:43:52,520 --> 00:43:54,145
ఈ రెండు విలువల మధ్య ఉందా?

1022
00:43:54,145 --> 00:43:56,811
పరిధి ప్రశ్నలు కాబట్టి ఈ రకమైన
మేము ఎల్లప్పుడూ ఆసక్తి ఉందని.

1023
00:43:56,811 --> 00:43:59,650
ఇప్పుడు డేటా గురించి ఒక విషయం, ఎప్పుడు
మీరు ఎప్పుడు డేటా యాక్సెస్ చూడండి

1024
00:43:59,650 --> 00:44:02,360
మీరు డేటాను ప్రాప్తి, అంతే
ఎల్లప్పుడూ ఒక సముదాయంగా గురించి.

1025
00:44:02,360 --> 00:44:05,770
ఇది రికార్డులు గురించి ఎప్పుడూ
ఈ సంబంధించినవి.

1026
00:44:05,770 --> 00:44:10,390
ఇక్కడ నాకు ప్రతిదీ ఇవ్వండి అన్ని that's--
ఈ క్రెడిట్ కార్డు లావాదేవీలకు

1027
00:44:10,390 --> 00:44:12,500
గత నెల.

1028
00:44:12,500 --> 00:44:13,960
ఒక సముదాయంగా ఉంది.

1029
00:44:13,960 --> 00:44:17,490
>> దాదాపు ప్రతిదీ మీరు చేయుచున్న
డేటాబేస్ అగ్రిగేషన్ రకమైన ఉంది.

1030
00:44:17,490 --> 00:44:21,530
నిర్వచించే చేయగలరు కాబట్టి ఉన్నందుకు చేయగలరు
ఈ బకెట్లు మరియు మీరు ఈ శ్రేణి ఇస్తుంది

1031
00:44:21,530 --> 00:44:24,950
ప్రశ్న చెయ్యలేరు విశేషణములు
ధనిక ఆ ప్రశ్నలకు, అనేక మద్దతు

1032
00:44:24,950 --> 00:44:27,165
అనేక అప్లికేషన్ ప్రాప్యత నమూనాలు.

1033
00:44:27,165 --> 00:44:30,990

1034
00:44:30,990 --> 00:44:35,000
>> ఇతర విషయం హాష్ కీ
డజ్ ఇట్ మాకు ఒక విధానం ఇస్తుంది

1035
00:44:35,000 --> 00:44:37,740
చుట్టూ ఇది దత్తాంశాలు వ్యాప్తి చెయ్యలేరు.

1036
00:44:37,740 --> 00:44:40,390
NoSQL డేటాబేస్ ఉత్తమ పని
డేటా సమానంగా ఉంది

1037
00:44:40,390 --> 00:44:41,740
క్లస్టర్ అంతటా పంపిణీ.

1038
00:44:41,740 --> 00:44:44,530

1039
00:44:44,530 --> 00:44:47,050
ఎంత మంది తెలిసిన
అల్గోరిథంలు హ్యాషింగ్ తో?

1040
00:44:47,050 --> 00:44:49,860
నేను హాష్ మరియు ఒక hashing-- చెప్పినప్పుడు
ఒక హ్యాషింగ్ అల్గోరిథం ఎందుకంటే

1041
00:44:49,860 --> 00:44:54,140
ఉత్పత్తి సామర్థ్యం యొక్క ఒక మార్గం
ఏ ఇచ్చిన విలువ నుండి రాండమ్ విలువ.

1042
00:44:54,140 --> 00:44:59,300
ఈ ప్రత్యేక సందర్భంలో,
మేము అమలు హాష్ క్రమసూత్ర పద్ధతి ND 5.

1043
00:44:59,300 --> 00:45:04,765
>> నేను ఒక ID కలిగి, మరియు ఈ ఉంటే
నా హాష్ కీ, నేను 1, 2, 3 కలిగి.

1044
00:45:04,765 --> 00:45:07,390
నేను హాష్ అల్గోరిథం అమలు చేసినప్పుడు,
అది తిరిగి వచ్చి చెప్పడానికి జరగబోతోంది

1045
00:45:07,390 --> 00:45:10,800
బాగా 1, 2 7b సమానం
48 సమానం 3 CD సమానం.

1046
00:45:10,800 --> 00:45:13,092
వారు అన్ని కీ స్పేస్ వ్యాపించి చేస్తున్నారు.

1047
00:45:13,092 --> 00:45:14,050
మరియు ఎందుకు మీరు ఈ చేయగలను?

1048
00:45:14,050 --> 00:45:17,120
ఖచ్చితంగా చేస్తుంది ఎందుకంటే ఆ నేను
బహుళ నోడ్లు అంతటా రికార్డులు చాలు.

1049
00:45:17,120 --> 00:45:19,574
>> నేను ఇలా చేస్తున్నాను ఉంటే
ఆరోహణ, 1, 2, 3.

1050
00:45:19,574 --> 00:45:21,990
నేను ఒక హాష్ పరిధిని కలిగి
ఈ ప్రత్యేక సందర్భంలో పరుగులు

1051
00:45:21,990 --> 00:45:24,785
ఒక చిన్న హాష్ స్పేస్,
అది, FF 00 నుండి నడుస్తుంది

1052
00:45:24,785 --> 00:45:27,951
అప్పుడు రికార్డులలో వచ్చిన వెళ్తున్నారు
మరియు వారు వెళ్ళి చూడాలని 1, 2, 3, 4, 5,

1053
00:45:27,951 --> 00:45:30,390
6, 7, 8, 9, 10, 11, 12.

1054
00:45:30,390 --> 00:45:31,800
ఏమి జరుగుతుంది?

1055
00:45:31,800 --> 00:45:34,860
ప్రతి చొప్పించు అదే నోడ్ అన్నారు.

1056
00:45:34,860 --> 00:45:36,070
మీరు వాట్ ఐ మీన్ చూడండి?

1057
00:45:36,070 --> 00:45:40,910
>> నేను స్పేస్ విడిపోవడంతో ఎందుకంటే,
మరియు నేను అంతటా ఈ రికార్డ్ వ్యాప్తి

1058
00:45:40,910 --> 00:45:45,950
మరియు నేను విభజన, నేను చెప్పడానికి వెళుతున్నాను
విభజన 1 నుంచి 54 కీ స్పేస్ 0 ఉంది.

1059
00:45:45,950 --> 00:45:47,720
విభజన 2 89 55 ఉంది.

1060
00:45:47,720 --> 00:45:49,780
విభజన 3 FF తో AA ఉంది.

1061
00:45:49,780 --> 00:45:53,740
నేను పెంచడం సరళంగా ఉపయోగించి వెబ్ చేస్తే
లను, మీరు ఏం చూడగలరు.

1062
00:45:53,740 --> 00:45:57,410
1, 2, 3, 4, 5, 6, 54, అన్ని మార్గం.

1063
00:45:57,410 --> 00:46:00,030
నేను hammering చేస్తున్నాను కాబట్టి
వ్యవస్థ రికార్డులు,

1064
00:46:00,030 --> 00:46:02,030
ప్రతిదీ ఒక నోడ్ అన్నారు ముగుస్తుంది.

1065
00:46:02,030 --> 00:46:03,160
>> మంచి కాదు.

1066
00:46:03,160 --> 00:46:04,820
ఒక antipattern వార్తలు.

1067
00:46:04,820 --> 00:46:08,760
MongoDB వారు ఈ సమస్య
మీరు ఒక హాష్ కీ ఉపయోగించడానికి లేకపోతే.

1068
00:46:08,760 --> 00:46:11,325
MongoDB అవకాశాన్ని కల్పిస్తుంది
కీ విలువ హ్యాషింగ్.

1069
00:46:11,325 --> 00:46:13,950
మీరు ఎల్లప్పుడూ ఉంటే, అలా ఉండాలి
మీరు ఒక పెంచడం హాష్ ఉపయోగిస్తున్నట్లయితే

1070
00:46:13,950 --> 00:46:17,380
MongoDB కీ, లేదా మీరు ఉంటాం
ఒక నోడ్ ప్రతి వ్రాయండి మేకులతో ఎముకలను కలుపుట

1071
00:46:17,380 --> 00:46:21,290
మరియు మీరు పరిమితం అవుతుంది
తీవ్రంగా మీ write నిర్గమాంశ.

1072
00:46:21,290 --> 00:46:24,896
>> ప్రేక్షకులు: దశాంశ ఆ A9 169 ఏమిటి?

1073
00:46:24,896 --> 00:46:28,450
>> రిక్ HOULIHAN: అవును, అంతే
ఎక్కడో అక్కడ చుట్టూ.

1074
00:46:28,450 --> 00:46:29,950
A9, నాకు తెలీదు.

1075
00:46:29,950 --> 00:46:32,200
మీరు నా బైనరీ పొందుటకు కలిగి ఇష్టం
దశాంశ కాలిక్యులేటర్.

1076
00:46:32,200 --> 00:46:34,237
నా మెదడు ఆ వంటి పని లేదు.

1077
00:46:34,237 --> 00:46:36,320
ప్రేక్షకులు: జస్ట్ ఎ క్విక్ వన్
మీ మొంగో వ్యాఖ్యలు.

1078
00:46:36,320 --> 00:46:39,530
కాబట్టి వచ్చే ఆబ్జెక్ట్ ID ఉంది
స్థానికంగా మొంగో తో అలా?

1079
00:46:39,530 --> 00:46:40,179

1080
00:46:40,179 --> 00:46:41,470
రిక్ HOULIHAN: ఆ ఏమి చేస్తుంది?

1081
00:46:41,470 --> 00:46:42,970
మీరు తెలిపితే.

1082
00:46:42,970 --> 00:46:45,030
MongoDB, మీరు అవకాశం ఉంటుంది.

1083
00:46:45,030 --> 00:46:48,930
మీరు ప్రతి పత్రం specify-- చేయవచ్చు
MongoDB ఒక అండర్ ID కలిగి ఉంది.

1084
00:46:48,930 --> 00:46:50,300
ఆ ఏకైక విలువ ఉంది.

1085
00:46:50,300 --> 00:46:55,240
>> MongoDB లో మీరు పేర్కొనవచ్చు
హాష్ లేదో.

1086
00:46:55,240 --> 00:46:56,490
వారు కేవలం మీరు ఐచ్ఛికాన్ని ఇవ్వటానికి.

1087
00:46:56,490 --> 00:46:58,198
మీరు ఇది తెలిస్తే
యాదృచ్ఛిక, సమస్య లేదు.

1088
00:46:58,198 --> 00:46:59,640
మీరు అలా అవసరం లేదు.

1089
00:46:59,640 --> 00:47:04,260
మీరు ఆ, యాదృచ్ఛిక కాదు తెలిస్తే
పెంచడం, అప్పుడు హాష్ చేయండి.

1090
00:47:04,260 --> 00:47:06,880
>> ఇప్పుడు విషయం గురించి
మీరు హాష్ ఒకసారి హ్యాషింగ్

1091
00:47:06,880 --> 00:47:08,800
ఒక విలువ మరియు ఈ
ఎందుకు హాష్ కీలను ఎల్లప్పుడూ

1092
00:47:08,800 --> 00:47:13,740
ఏకైక ప్రశ్నలు, నేను మార్చారు ఎందుకంటే
విలువ, ఇప్పుడు నేను ఒక పరిధి ప్రశ్న చెయ్యలేరు.

1093
00:47:13,740 --> 00:47:15,640
నేను ఈ చెప్పలేము
ఈ లేదా ఆ మధ్య

1094
00:47:15,640 --> 00:47:20,800
హాష్ విలువ ఉండదని ఎందుకంటే
అసలు విలువకు సమానంగా ఉంటుందని.

1095
00:47:20,800 --> 00:47:24,570
కాబట్టి మీరు హాష్ ఉన్నప్పుడు
కీ, ఇది మాత్రమే సమానత్వం ఉంది.

1096
00:47:24,570 --> 00:47:28,700
ఈ ఎందుకు DynamoDB హాష్ కీ ఉంది
ప్రశ్నలు ఎల్లప్పుడూ మాత్రమే సమానత్వం ఉంటాయి.

1097
00:47:28,700 --> 00:47:32,090

1098
00:47:32,090 --> 00:47:34,700
>> కాబట్టి ఇప్పుడు ఒక పరిధిలో key--
నేను ఆ పరిధిలో కీ జతచేయునప్పుడు,

1099
00:47:34,700 --> 00:47:38,180
ఆ పరిధి కీ రికార్డులు అన్ని లో వచ్చి
వారు అదే విభజనలో నిల్వ కలుగుతుంది.

1100
00:47:38,180 --> 00:47:42,430
కాబట్టి అవి సులభంగా, చాలా త్వరగా
ఈ హాష్ ఎందుకంటే, రిట్రీవ్డ్

1101
00:47:42,430 --> 00:47:43,220
ఈ పరిధిలో ఉంది.

1102
00:47:43,220 --> 00:47:44,928
మరియు మీరు ప్రతిదీ చూడండి
అదే హాష్

1103
00:47:44,928 --> 00:47:48,550
అదే విభజన స్పేస్ లో నిల్వ కావాలి.

1104
00:47:48,550 --> 00:47:53,889
మీరు సహాయం ఆ పరిధిలో కీ ఉపయోగించవచ్చు
దాని మాతృ దగ్గరగా మీ డేటా గుర్తించడం.

1105
00:47:53,889 --> 00:47:55,180
నేను నిజంగా ఇక్కడ ఏమి చేస్తున్నాను?

1106
00:47:55,180 --> 00:47:57,320
ఈ అనేక సంబంధం ఒక ఒకటి.

1107
00:47:57,320 --> 00:48:01,490
ఒక హాష్ కీ మధ్య సంబంధం
మరియు పరిధి కీ అనేక ఒకటి.

1108
00:48:01,490 --> 00:48:03,490
నేను బహుళ హాష్ కీలు కలిగి ఉంటాయి.

1109
00:48:03,490 --> 00:48:07,610
నేను మాత్రమే బహుళ పరిధి కలిగి ఉంటాయి
ప్రతి హాష్ కీ లోపల కీలు.

1110
00:48:07,610 --> 00:48:11,910
>> హాష్ మాతృ నిర్వచిస్తుంది
పరిధి పిల్లలు నిర్వచిస్తుంది.

1111
00:48:11,910 --> 00:48:15,240
కాబట్టి మీరు చూడగలరు అనలాగ్ ఇక్కడ ఉంది
రిలేషనల్ నిర్మాణం మధ్య

1112
00:48:15,240 --> 00:48:18,840
మరియు అదే రకాల
NoSQL లో నిర్మిస్తుంది.

1113
00:48:18,840 --> 00:48:20,760
ప్రజలు మాట్లాడటానికి
Nonrelational వంటి NoSQL.

1114
00:48:20,760 --> 00:48:22,200
ఇది nonrelational కాదు.

1115
00:48:22,200 --> 00:48:24,680
డేటా ఎల్లప్పుడూ సంబంధాలు కలిగి ఉంది.

1116
00:48:24,680 --> 00:48:28,172
ఆ సంబంధాలు కేవలం
విభిన్నంగా చేశారు.

1117
00:48:28,172 --> 00:48:29,880
యొక్క కొద్దిగా మాట్లాడటానికి లెట్
మన్నిక గురించి బిట్.

1118
00:48:29,880 --> 00:48:34,860
మీరు DynamoDB వ్రాసే సమయంలో వ్రాస్తూ
ఎల్లప్పుడూ మూడు-మార్గం నకళ్లుగా కన్పిస్తాయి.

1119
00:48:34,860 --> 00:48:37,550
మేము మూడు AZ యొక్క ఉందని అర్థం.

1120
00:48:37,550 --> 00:48:39,160
AZ యొక్క అందుబాటులో ఉన్న ప్రాంతాలు ఉన్నాయి.

1121
00:48:39,160 --> 00:48:43,430
మీరు ఒక అందుబాటు ఆలోచించవచ్చు
ఒక డేటా సెంటర్ వంటి జోన్

1122
00:48:43,430 --> 00:48:45,447
డేటా కేంద్రాలలో లేదా సేకరణను.

1123
00:48:45,447 --> 00:48:47,780
ఈ విషయాలు భౌగోళికంగా
ప్రతి ఇతర నుండి వేరుచేయబడుతుంది

1124
00:48:47,780 --> 00:48:51,610
వివిధ లోపం మండలాలు అంతటా, అంతటా
విద్యుత్ గ్రిడ్లు మరియు వరదముంపుకు వివిధ.

1125
00:48:51,610 --> 00:48:54,510
ఒక AZ ఒక వైఫల్యం కాదు
మరొక డౌన్ తీసుకోవాలని అన్నారు.

1126
00:48:54,510 --> 00:48:56,890
వారు కూడా అనుసంధానించబడ్డాయి
కలిసి డార్క్ ఫైబర్ తో.

1127
00:48:56,890 --> 00:49:01,240
ఇది ఒక ఉప మద్దతు 1
AZs మధ్య మిల్లిసెకనులో అంతర్గతాన్ని.

1128
00:49:01,240 --> 00:49:05,390
సో నిజ సమయంలో డేటా replications
బహుళ AZs లో సామర్థ్యం.

1129
00:49:05,390 --> 00:49:09,990
>> మరియు తరచు బహుళ AZ మోహరింపుకు
అధిక లభ్యత అవసరాలు తీర్చేందుకు

1130
00:49:09,990 --> 00:49:12,930
చాలా Enterprise సంస్థల.

1131
00:49:12,930 --> 00:49:16,139
కాబట్టి DynamoDB వ్యాపించి ఉంది
అప్రమేయంగా మూడు AZs అంతటా.

1132
00:49:16,139 --> 00:49:19,430
మేము మాత్రమే జ్ఞానం రాయాలో
ఆ మూడు కణుపులు రెండు తిరిగి వచ్చినప్పుడు

1133
00:49:19,430 --> 00:49:21,470
మరియు నేను వచ్చింది, అవును, చెప్పటానికి.

1134
00:49:21,470 --> 00:49:22,050
ఎందుకు అని?

1135
00:49:22,050 --> 00:49:25,950
రీడ్ వైపు ఉన్నారు మాత్రమే
తిరిగి మీరు డేటా ఇవ్వాలని అన్నారు

1136
00:49:25,950 --> 00:49:27,570
మేము రెండు నోడ్స్ నుండి పొందండి.

1137
00:49:27,570 --> 00:49:30,490
>> నేను అంతటా పునరావృత్తం చేస్తున్నాను ఉంటే
మూడు, మరియు నేను రెండు నుండి వింటున్నాను,

1138
00:49:30,490 --> 00:49:32,840
నేను ఎల్లప్పుడూ హామీ చేస్తున్నాను
కనీసం ఒక కలిగి

1139
00:49:32,840 --> 00:49:35,720
ఆ ఉండాలి చదువుతుంది
డేటా అత్యంత ప్రస్తుత నకలు.

1140
00:49:35,720 --> 00:49:38,340
ఆ DynamoDB స్థిరమైన చేస్తుంది ఏమిటి.

1141
00:49:38,340 --> 00:49:42,450
ఇప్పుడు మీరు చెయ్యడానికి ఎంచుకోవచ్చు
ఆ స్థిరమైన ఆఫ్ చదువుతుంది.

1142
00:49:42,450 --> 00:49:45,070
ఈ సందర్భంలో నేను చెప్పడానికి వెళుతున్నాను,
నేను మాత్రమే ఒక నోడ్ నుండి చదివి ఉంటాం.

1143
00:49:45,070 --> 00:49:47,430
మరియు నేను దానిని జరగబోతోంది హామీ కాదు
అత్యంత ప్రస్తుత డేటా ఉండాలి.

1144
00:49:47,430 --> 00:49:49,450
>> ఒక వ్రాయడం వస్తున్న చేస్తే,
అది ఇంకా ప్రతిరూపం లేదు

1145
00:49:49,450 --> 00:49:50,360
మీరు ఆ కాపీని పొందడానికి వెళుతున్న.

1146
00:49:50,360 --> 00:49:52,220
ఒక చివరికి స్థిరమైన రీడ్ ఉంది.

1147
00:49:52,220 --> 00:49:54,640
మరియు ఆ సగం ఖర్చు.

1148
00:49:54,640 --> 00:49:56,140
కాబట్టి దీని గురించి ఆలోచించడం ఏదో ఉంది.

1149
00:49:56,140 --> 00:50:00,160
చేసినప్పుడు మీరు DynamoDB బయటకు చదవడానికి, మరియు చేస్తున్నారు
మీరు మీ రీడ్ సామర్థ్యం ఏర్పాటు చేస్తున్నారు

1150
00:50:00,160 --> 00:50:04,430
యూనిట్లు, మీరు చివరకు ఎంచుకుంటే
స్థిరమైన, ఇది చాలా చవకగా ఉంది, చదువుతుంది

1151
00:50:04,430 --> 00:50:06,010
దాని గురించి సగం ఖర్చు వార్తలు.

1152
00:50:06,010 --> 00:50:09,342
>> కావున మీరు డబ్బు ఆదా.

1153
00:50:09,342 --> 00:50:10,300
కానీ మీ ఎంపిక యొక్క.

1154
00:50:10,300 --> 00:50:12,925
మీరు స్థిరమైన రీడ్ అనుకుంటే లేదా
ఒక చివరికి స్థిరమైన రీడ్.

1155
00:50:12,925 --> 00:50:15,720
మీరు ఎంచుకోవచ్చు ఏదో వార్తలు.

1156
00:50:15,720 --> 00:50:17,659
>> యొక్క సూచికలు గురించి చర్చిద్దాం.

1157
00:50:17,659 --> 00:50:19,450
కాబట్టి మేము ఆ ప్రస్తావన
ఉన్నత స్థాయిలో అగ్రిగేషన్.

1158
00:50:19,450 --> 00:50:23,720
మేము హాష్ కీలను వచ్చింది చేసిన, మరియు
మేము పరిధిలో కీలను పొందారు.

1159
00:50:23,720 --> 00:50:24,320
అది బాగుంది.

1160
00:50:24,320 --> 00:50:26,950
మరియు ఆ, ప్రాధమిక టేబుల్పై నేను
ఒక హాష్ కీ వచ్చింది, నేను ఒక పరిధి కీ వచ్చింది.

1161
00:50:26,950 --> 00:50:27,783
>> ఆ అర్థం ఏమిటి?

1162
00:50:27,783 --> 00:50:30,410
నేను ఒక లక్షణం పొందారు నేను
వ్యతిరేకంగా గొప్ప ప్రశ్నలు అమలు చేయవచ్చు.

1163
00:50:30,410 --> 00:50:31,800
ఇది పరిధి కీ ఉంది.

1164
00:50:31,800 --> 00:50:35,530
ఆ item-- ఇతర లక్షణాలను
నేను ఆ గుణాలను ఫిల్టర్ చెయ్యవచ్చు.

1165
00:50:35,530 --> 00:50:40,050
కానీ నేను విషయాలు వంటి చెయ్యలేరని
ప్రారంభమవుతుంది, లేదా కంటే ఎక్కువ.

1166
00:50:40,050 --> 00:50:40,820
>> నేను ఎలా చెయ్యాలి?

1167
00:50:40,820 --> 00:50:42,860
నేను ఒక సూచిక సృష్టించడానికి.

1168
00:50:42,860 --> 00:50:45,340
రెండు రకాల ఉంది
DynamoDB లో సూచికలు.

1169
00:50:45,340 --> 00:50:49,002
సూచికను నిజంగా
పట్టిక మరొక వీక్షణ.

1170
00:50:49,002 --> 00:50:50,490
స్థానిక ద్వితీయ సూచిక.

1171
00:50:50,490 --> 00:50:51,781
>> మనం మాట్లాడదాము మొదటి ఒకటి.

1172
00:50:51,781 --> 00:50:57,740
సో స్థానిక సెకండరీ పాటుగా ఉంటాయి
డేటా అదే విభజనపై.

1173
00:50:57,740 --> 00:51:00,240
మరియు వంటి, వారు ఉన్నాయి
ఒకే భౌతిక నోడ్.

1174
00:51:00,240 --> 00:51:01,780
వారు మేము స్థిరమైన అంటాము.

1175
00:51:01,780 --> 00:51:04,599
మీనింగ్ వారు గుర్తించి కనిపిస్తుంది
పట్టిక పాటు వ్రాయండి.

1176
00:51:04,599 --> 00:51:06,890
వ్రాసిన వచ్చినప్పుడు,
మేము ఇండెక్స్ ద్వారా వ్రాయండి చేస్తాము.

1177
00:51:06,890 --> 00:51:09,306
మేము పట్టిక వ్రాయండి చేస్తాము
ఆపై మేము గుర్తించి కనిపిస్తుంది.

1178
00:51:09,306 --> 00:51:10,490
కాబట్టి ఆ స్థిరంగా.

1179
00:51:10,490 --> 00:51:13,174
వ్రాసే ఉంది ఒకసారి
పట్టిక నుండి తెలియజేసారు,

1180
00:51:13,174 --> 00:51:15,090
ఆ హామీ
స్థానిక ద్వితీయ సూచిక

1181
00:51:15,090 --> 00:51:18,380
డేటా అదే దృష్టి ఉంటుంది.

1182
00:51:18,380 --> 00:51:22,390
కానీ ఏమి వారు అనుమతిస్తుంది మీరు చేయాల్సిందల్లా
ప్రత్యామ్నాయ పరిధి కీలను వివరిస్తాయి.

1183
00:51:22,390 --> 00:51:25,260
>> అదే హాష్ ఉపయోగించాలి
ప్రాథమిక పట్టిక కీ,

1184
00:51:25,260 --> 00:51:29,050
వారు ఎందుకంటే న సహ ఉన్న
అదే విభజన, మరియూ వారు స్థిరమైన ఉన్నారు.

1185
00:51:29,050 --> 00:51:33,110
కానీ నేను ఒక ఇండెక్స్ సృష్టించవచ్చు
వివిధ శ్రేణి కీలు తో.

1186
00:51:33,110 --> 00:51:41,590
ఉదాహరణకు, నేను ఒక తయారీదారు కలిగి
ఒక ముడి భాగాలు పట్టిక వస్తున్న వచ్చింది.

1187
00:51:41,590 --> 00:51:44,590
మరియు ముడి భాగాలు వస్తాయి, మరియు
వారు అసెంబ్లీ సమగ్రం చేస్తున్నారు.

1188
00:51:44,590 --> 00:51:46,840
మరియు ఉండవచ్చు ఒక రీకాల్ ఉంది.

1189
00:51:46,840 --> 00:51:50,240
>> ఈ నిర్ణయాన్ని తీసుకున్నట్లు పేర్కొంది ఏ భాగం
ఈ తేదీ తర్వాత తయారీదారు,

1190
00:51:50,240 --> 00:51:52,840
నేను నా లైన్ నుండి తీసి అవసరం.

1191
00:51:52,840 --> 00:51:55,950
నేను ఒక ఇండెక్స్ స్పిన్ చేయవచ్చు
ఆ చూస్తున్న అవుతుంది

1192
00:51:55,950 --> 00:52:00,760
తేదీ సంకలనం
నిర్దిష్ట భాగం తయారు చేస్తాయి.

1193
00:52:00,760 --> 00:52:03,930
నా మొదటి స్థాయి టేబుల్ ఉంది కనుక
ఇప్పటికే తయారీదారు హ్యాష్,

1194
00:52:03,930 --> 00:52:07,655
దీనికి నేను, భాగం ID ఏర్పాటు చేశారు
పట్టిక ఆఫ్ సూచిక సృష్టించడానికి చేయవచ్చు

1195
00:52:07,655 --> 00:52:11,140
తయారీదారు హ్యాష్ మరియు
తయారీ తేదీ లో ఉంటుంది.

1196
00:52:11,140 --> 00:52:14,490
నేను చెప్పగల్గినవి మార్గం ఏదైనా ఆ
తారీఖులలో మధ్య తయారు చేశారు,

1197
00:52:14,490 --> 00:52:16,804
నేను లైన్ నుండి తీసి అవసరం.

1198
00:52:16,804 --> 00:52:18,220
కాబట్టి ఒక స్థానిక ద్వితీయ సూచిక ఉంది.

1199
00:52:18,220 --> 00:52:22,280
>> ఈ ప్రభావం
మీ హాష్ కీ స్పేస్ పరిమితం.

1200
00:52:22,280 --> 00:52:24,360
వారు ఎందుకంటే సహ ఉనికిలో
అదే నిల్వ నోడ్ పై,

1201
00:52:24,360 --> 00:52:26,860
వారు హాష్ కీ పరిమితం
10 గిగా స్పేస్.

1202
00:52:26,860 --> 00:52:28,950
DynamoDB కింద
పట్టికలు, దేశ విభజన ఉంటుంది

1203
00:52:28,950 --> 00:52:31,380
మీ పట్టిక ప్రతి 10 గిగాబైట్ల.

1204
00:52:31,380 --> 00:52:34,760
మీరు డేటా 10 వేదికలను లో ఉంచారు, మేము
[PHH] వెళ్ళి, మరియు మేము మరొక నోడ్ జోడించండి.

1205
00:52:34,760 --> 00:52:38,120

1206
00:52:38,120 --> 00:52:42,070
>> మేము LSI విడిపోకుండా ఉంటుంది
బహుళ విభజనలను అంతటా.

1207
00:52:42,070 --> 00:52:43,200
మేము పట్టిక విభజించబడింది చేస్తాము.

1208
00:52:43,200 --> 00:52:44,679
కానీ మేము LSI విడిపోకుండా ఉంటుంది.

1209
00:52:44,679 --> 00:52:46,470
ఏదో సో
అర్థం ముఖ్యం

1210
00:52:46,470 --> 00:52:50,070
మీరు చాలా చేస్తున్నా ఉంది,
చాలా, చాలా పెద్ద aggregations,

1211
00:52:50,070 --> 00:52:53,860
అప్పుడు మీరు పరిమితం కావడం
మీ LSIs 10 గిగా.

1212
00:52:53,860 --> 00:52:56,640
>> ఒకవేళ, మేము
ప్రపంచ సెకండరీ ఉపయోగించండి.

1213
00:52:56,640 --> 00:52:58,630
గ్లోబల్ సెకండరీ ఉంటాయి
నిజంగా మరొక పట్టిక.

1214
00:52:58,630 --> 00:53:01,720
వారు ఆఫ్ మనుగడలో
మీ ప్రాథమిక పట్టిక వైపు.

1215
00:53:01,720 --> 00:53:04,680
మరియు వారు నాకు ఒక కనుగొనడానికి అనుమతిస్తుంది
పూర్తిగా భిన్నంగా నిర్మాణాన్ని.

1216
00:53:04,680 --> 00:53:08,010
డేటా చేర్చబడ్డ చేస్తున్నారు కాబట్టి ఆలోచించి
రెండు వేర్వేరు పట్టికలు లోకి, నిర్మాణాత్మక

1217
00:53:08,010 --> 00:53:09,220
రెండు రకాలుగా.

1218
00:53:09,220 --> 00:53:11,360
>> నేను పూర్తిగా నిర్వచించలేదు
వివిధ హాష్ కీ.

1219
00:53:11,360 --> 00:53:13,490
నేను పూర్తిగా నిర్వచించలేదు
వివిధ శ్రేణి కీ.

1220
00:53:13,490 --> 00:53:15,941
నేను ఈ అమలు చేయవచ్చు
పూర్తిగా స్వతంత్రంగా.

1221
00:53:15,941 --> 00:53:18,190
వాస్తవానికి, నేను చేసిన
నా రీడ్ సామర్థ్యం కేటాయించినవి

1222
00:53:18,190 --> 00:53:21,090
మరియు సామర్థ్య రాయడానికి నా
ప్రపంచ ద్వితీయ సూచికలు

1223
00:53:21,090 --> 00:53:24,240
పూర్తిగా స్వతంత్రంగా
నా ప్రాధమిక పట్టిక.

1224
00:53:24,240 --> 00:53:26,640
నేను ఆ సూచిక నిర్వచించే ఉంటే, నేను చెప్పడానికి
అది ఎంత చదవడం మరియు వ్రాయడం

1225
00:53:26,640 --> 00:53:28,610
సామర్థ్యం అది ఉపయోగించి చేస్తాడు.

1226
00:53:28,610 --> 00:53:31,490
>> మరియు ఆ వేరుగా ఉంటుంది
నా ప్రాథమిక పట్టిక నుండి.

1227
00:53:31,490 --> 00:53:35,240
ఇప్పుడు సూచీలు రెండు మమ్మల్ని అనుమతించడం
మాత్రమే, హాష్ మరియు పరిధి కీలను నిర్వచించే

1228
00:53:35,240 --> 00:53:38,610
కానీ వారు మమ్మల్ని అనుమతించడం
అదనపు విలువలు అంచనా వేస్తున్నాయి.

1229
00:53:38,610 --> 00:53:44,950
నేను ఇండెక్స్ ఆఫ్ చదవడానికి కావాలా సో,
నేను సమాచారం యొక్క కొన్ని సెట్ పొందడానికి కావలసిన,

1230
00:53:44,950 --> 00:53:48,327
నేను ప్రధాన తిరిగి వెళ్ళడానికి అవసరం లేదు
పట్టిక అదనపు లక్షణాలను పొందడానికి.

1231
00:53:48,327 --> 00:53:50,660
నేను ఆ అదనపు అంటున్నారు చేయవచ్చు
పట్టిక లోకి లక్షణాలను

1232
00:53:50,660 --> 00:53:53,440
యాక్సెస్ నమూనా మద్దతు.

1233
00:53:53,440 --> 00:53:57,700
నేను మేము బహుశా కొన్ని లోకి పొందుతుంటే తెలుసు
నిజంగా, కలుపు మొక్కలు వెళ్ళడం నిజంగా

1234
00:53:57,700 --> 00:53:58,910
ఇక్కడ ఈ విషయాన్ని కొన్ని న.

1235
00:53:58,910 --> 00:54:02,725
ఇప్పుడు నేను ఈ నుండి మళ్ళడం వచ్చింది.

1236
00:54:02,725 --> 00:54:07,320
>> ప్రేక్షకులు: [వినబడని]
--table కీ ఒక హాష్ భావించారు?

1237
00:54:07,320 --> 00:54:08,840
అసలు హాష్?

1238
00:54:08,840 --> 00:54:09,340
బహుళ పలకల?

1239
00:54:09,340 --> 00:54:10,200
>> రిక్ HOULIHAN: అవును.

1240
00:54:10,200 --> 00:54:11,070
అవును.

1241
00:54:11,070 --> 00:54:15,260
పట్టిక కీ ప్రాథమికంగా
తిరిగి అంశానికి చూపాడు.

1242
00:54:15,260 --> 00:54:19,280
అయితే ఇండెక్స్ ఒక పాయింటర్ తిరిగి ఉంది
పట్టిక అసలు అంశాలు.

1243
00:54:19,280 --> 00:54:22,910
ఇప్పుడు మీరు ఒక నిర్మించడానికి ఎంచుకోవచ్చు
మాత్రమే పట్టిక కీ కలిగి ఇండెక్స్,

1244
00:54:22,910 --> 00:54:24,840
మరియు ఏ ఇతర లక్షణాలు.

1245
00:54:24,840 --> 00:54:26,570
నేను ఎందుకు ఆ ఏమి ఉండవచ్చు?

1246
00:54:26,570 --> 00:54:28,570
Well, నేను చాలా పెద్ద అంశాలు ఉన్నాయి.

1247
00:54:28,570 --> 00:54:31,660
>> నేను నిజంగా మాత్రమే తెలుసుకోవాలి which--
నా యాక్సెస్ నమూనా, అనవచ్చు

1248
00:54:31,660 --> 00:54:33,760
ఇది అంశాలను ఈ ఆస్తి కలిగి?

1249
00:54:33,760 --> 00:54:35,780
అంశం తిరిగి అవసరం లేదు.

1250
00:54:35,780 --> 00:54:37,800
నేను తెలుసుకోవాలి కేవలం
ఇది అంశాలను కలిగి ఉంటాయి.

1251
00:54:37,800 --> 00:54:40,700
కాబట్టి మీరు సూచికలు నిర్మించవచ్చు
ఆ మాత్రమే పట్టిక కీ ఉంది.

1252
00:54:40,700 --> 00:54:43,360
>> కానీ ఆ ప్రధానంగా ఏమిటి
డేటాబేస్ లో ఒక ఇండెక్స్ కోసం.

1253
00:54:43,360 --> 00:54:46,280
ఇది త్వరగా సామర్థ్యం కోసం వార్తలు
రికార్డులు గుర్తించడానికి

1254
00:54:46,280 --> 00:54:49,470
ఇది వరుసలు, ఇది
పట్టిక అంశాలను కలిగి

1255
00:54:49,470 --> 00:54:51,080
నేను శోధించడం నేను ధర్మాలు.

1256
00:54:51,080 --> 00:54:53,610

1257
00:54:53,610 --> 00:54:54,860
>> GSIs, కాబట్టి ఎలా పని చేస్తాయి?

1258
00:54:54,860 --> 00:54:58,340
GSIs ప్రధానంగా అసమకాలిక ఉన్నాయి.

1259
00:54:58,340 --> 00:55:02,570
నవీకరణ పట్టిక లోకి వస్తుంది,
పట్టిక అప్పుడు క్రమపద్దతిలో నవీకరించబడింది

1260
00:55:02,570 --> 00:55:03,720
మీ GSIs అన్ని.

1261
00:55:03,720 --> 00:55:06,680
GSIs ఎందుకు ఉంది
చివరికి స్థిరమైన.

1262
00:55:06,680 --> 00:55:09,440
>> ఇది గమనించండి ముఖ్యం
చేసినప్పుడు మీరు GSIs నిర్మించడం చేస్తున్నారు,

1263
00:55:09,440 --> 00:55:13,110
మరియు మీరు సృష్టిస్తున్నారు అర్థం
aggregation-- మరొక కోణాన్ని

1264
00:55:13,110 --> 00:55:16,594
ఇప్పుడు యొక్క ఒక మంచి ఉదాహరణ అని పిలవబడు
ఇక్కడ ఒక తయారీదారు.

1265
00:55:16,594 --> 00:55:19,260
నేను గురించి మాట్లాడారు ఆలోచిస్తున్న
ఒక వైద్య పరికరం తయారీదారు.

1266
00:55:19,260 --> 00:55:23,870
మెడికల్ పరికరం తయారీదారులు
తరచు సీరియల్ భాగాలు ఉంటాయి.

1267
00:55:23,870 --> 00:55:28,070
అవసరమయ్యే భాగాలు
ఒక హిప్ భర్తీ అన్ని

1268
00:55:28,070 --> 00:55:30,200
వాటిని కొద్దిగా సీరియల్ సంఖ్యలో ఉన్నాయి.

1269
00:55:30,200 --> 00:55:33,584
మరియు వారు లక్షల కలిగి కాలేదు మరియు
లక్షలాది మరియు భాగాలు బిలియన్ల

1270
00:55:33,584 --> 00:55:35,000
వారు యిచ్చిన అన్ని పరికరాల్లో.

1271
00:55:35,000 --> 00:55:37,440
Well, వారు కింద సమష్టి అవసరం
వివిధ కోణాలు, అన్ని భాగాలు

1272
00:55:37,440 --> 00:55:39,520
ఒక సమావేశ మందిరంలో, అన్ని
వారు ఈ భాగాలు

1273
00:55:39,520 --> 00:55:41,670
ఒక నిర్దిష్ట లైన్ పై, అన్ని
వచ్చిన ప్రాంతాల

1274
00:55:41,670 --> 00:55:44,620
ఒక నిర్దిష్ట తయారీదారు నుండి
ఒక నిర్దిష్ట తేదీ.

1275
00:55:44,620 --> 00:55:47,940
కొన్నిసార్లు ఈ aggregations
బిలియన్స్ నిలపడానికి.

1276
00:55:47,940 --> 00:55:50,550
>> నేను కొన్ని పని
బాధల్లో ఈ కుర్రాళ్ళు

1277
00:55:50,550 --> 00:55:53,156
వారు సృష్టిస్తున్నారు ఎందుకంటే
ఈ ginormous aggregations

1278
00:55:53,156 --> 00:55:54,280
వారి ఉన్నత సూచీల్లో.

1279
00:55:54,280 --> 00:55:57,070
వారు ఒక ముడి భాగాలు కలిగి ఉండవచ్చు
హాష్ మాత్రమే వస్తుంది పట్టిక.

1280
00:55:57,070 --> 00:55:59,090
ప్రతి భాగం ఒక ఏకైక సీరియల్ నంబర్ ఉంది.

1281
00:55:59,090 --> 00:56:00,975
నేను హాష్ క్రమ సంఖ్య ఉపయోగించండి.

1282
00:56:00,975 --> 00:56:01,600
ఇది బావుంది.

1283
00:56:01,600 --> 00:56:04,160
నా ముడి డేటా పట్టిక వ్యాపించి ఉంది
అన్ని కీ స్పేస్ అంతటా.

1284
00:56:04,160 --> 00:56:05,930
నా [? వ్రాయడానికి?]
[? త్రాగుట?] అద్భుతం.

1285
00:56:05,930 --> 00:56:07,876
నేను సమాచారం యొక్క చాలా పడుతుంది.

1286
00:56:07,876 --> 00:56:09,500
అప్పుడు వారు ఏమి వారు ఒక GSI సృష్టించడానికి ఉంది.

1287
00:56:09,500 --> 00:56:12,666
మరియు నేను చూడండి అవసరం, మీరు ఏమి తెలుసు, చెప్పటానికి
ఈ తయారీదారు కోసం అన్ని భాగాలు.

1288
00:56:12,666 --> 00:56:15,060
Well, ఒక ఆకస్మికంగా నేను ఉన్నాను
ఒక బిలియన్ వరుసలు తీసుకొని,

1289
00:56:15,060 --> 00:56:17,550
తోలడం మరియు వాటిని అంశాలు
ఒక నోడ్, ఎందుకంటే చేసినప్పుడు

1290
00:56:17,550 --> 00:56:21,170
నేను సమష్టి
హాష్ తయారీదారు ID,

1291
00:56:21,170 --> 00:56:25,410
మరియు పరిధిగా పార్ట్ సంఖ్య,
అప్పుడు నేను అకస్మాత్తుగా అన్ని

1292
00:56:25,410 --> 00:56:30,530
ఒక బిలియన్ భాగాలు ఉంచడం ఏమి
ఈ తయారీదారు నాకు వెలువరించింది.

1293
00:56:30,530 --> 00:56:34,447
>> ఆ చాలా కారణమవుతుంది
GSI ఒత్తిడి,

1294
00:56:34,447 --> 00:56:36,030
మళ్ళీ, నేను ఒక నోడ్ hammering చేస్తున్నాను ఎందుకంటే.

1295
00:56:36,030 --> 00:56:38,350
నేను అన్ని ఈ ఆటంకమవుతుంది
ఒక నోడ్ లోకి ఇన్సర్ట్.

1296
00:56:38,350 --> 00:56:40,940
మరియు ఆ నిజమైన సమస్యాత్మక వినియోగం కేస్.

1297
00:56:40,940 --> 00:56:43,479
ఇప్పుడు నేను ఒక మంచి డిజైన్ వచ్చింది
మీరు ఆ నివారించేందుకు ఎలా నమూనా.

1298
00:56:43,479 --> 00:56:45,770
మరియు ఆ సమస్యలు ఒకటి
నేను ఎల్లప్పుడూ పని.

1299
00:56:45,770 --> 00:56:49,590
ఏమి కానీ, GSI ఉండవచ్చు
తగినంత వ్రాయండి సామర్థ్యం లేదు

1300
00:56:49,590 --> 00:56:52,330
అన్ని ఆ పుష్ చెయ్యలేరు
ఒకే నోడ్ లోకి వరుసలు.

1301
00:56:52,330 --> 00:56:55,390
మరియు అప్పుడు ఏమి ఉంది
ప్రాధమిక, క్లయింట్ పట్టిక,

1302
00:56:55,390 --> 00:57:00,180
ప్రాథమిక పట్టిక ఆపేసారు చేయబడుతుంది
GSI ఉంచడానికి కాదు ఎందుకంటే.

1303
00:57:00,180 --> 00:57:02,980
కాబట్టి నా చొప్పించు రేటు రెడీ
ప్రాథమిక పట్టిక వస్తాయి

1304
00:57:02,980 --> 00:57:06,230
నా GSI తెలియచేయడానికి ప్రయత్నిస్తాడు.

1305
00:57:06,230 --> 00:57:08,850
>> అన్ని కుడి, LSI యొక్క, GSI యొక్క కాబట్టి,
నేను ఒక వాడాలి?

1306
00:57:08,850 --> 00:57:12,290
LSI యొక్క స్థిరంగా ఉంటాయి.

1307
00:57:12,290 --> 00:57:13,750
GSI క్రమంగా స్థిరంగా ఉంటాయి.

1308
00:57:13,750 --> 00:57:17,490
ఆ సరే ఉంటే, నేను ఒక ఉపయోగించి సిఫార్సు
GSI, వారు మరింత సౌకర్యవంతమైన ఉన్నాము.

1309
00:57:17,490 --> 00:57:20,270
LSI యొక్క ఒక GSI వలె తయారు చేయవచ్చు.

1310
00:57:20,270 --> 00:57:27,040
మరియు ఉంటే హాష్ కీలను ప్రకారం డేటా పరిమాణంలో
మీ సేకరణ 10 గిగాబైట్ల మించిపోయింది

1311
00:57:27,040 --> 00:57:31,050
అప్పుడు మీరు ఆ ఉపయోగించాలనుకుంటున్నాను చూడాలని
GSI అది కేవలం ఒక హార్డ్ పరిమితి ఎందుకంటే.

1312
00:57:31,050 --> 00:57:32,035
>> All right, కాబట్టి స్కేలింగ్.

1313
00:57:32,035 --> 00:57:35,210

1314
00:57:35,210 --> 00:57:37,460
డైనమో DB లో మొత్తం మీరు
చెయ్యవచ్చు సదుపాయం [వినబడని]

1315
00:57:37,460 --> 00:57:38,680
పట్టిక నిర్గమాంశ.

1316
00:57:38,680 --> 00:57:42,740
మేము కలిగి వినియోగదారులు కలిగి
కేటాయించినవి 60 billion--

1317
00:57:42,740 --> 00:57:45,970
క్రమం తప్పకుండా 60 బిలియన్ల అభ్యర్థనలు చేస్తున్న
పది లక్షలకు పైగా అభ్యర్థనలు వద్ద నడుస్తున్న

1318
00:57:45,970 --> 00:57:47,790
మా పట్టికలు న సెకనుకు.

1319
00:57:47,790 --> 00:57:50,360
ఏ నిజంగా ఉంది
సిద్ధాంతపరమైన పరిమితి ఎంత

1320
00:57:50,360 --> 00:57:53,730
మరియు ఎంత వేగంగా పట్టిక
డైనమో DB లో అమలు చెయ్యవచ్చు.

1321
00:57:53,730 --> 00:57:55,920
కొన్ని సాఫ్ట్ ఉన్నాయి
మీ ఖాతాలో పరిమితులు

1322
00:57:55,920 --> 00:57:58,170
మేము అలా అక్కడ పెట్టే
మీరు గో క్రేజీ లేదు.

1323
00:57:58,170 --> 00:58:00,070
మీరు కంటే ఎక్కువ కావాలంటే
ఆ, ఒక సమస్య.

1324
00:58:00,070 --> 00:58:00,820
మీరు మాకు చెప్పండి వస్తాయి.

1325
00:58:00,820 --> 00:58:02,810
మేము డయల్ అప్ మారిపోతాయి చేస్తాము.

1326
00:58:02,810 --> 00:58:08,210
>> ప్రతి ఖాతా కొన్ని స్థాయికి పరిమితం
ప్రతి సేవ, కేవలం బ్యాట్ ఆఫ్

1327
00:58:08,210 --> 00:58:11,920
కాబట్టి ప్రజలు గో క్రేజీ లేదు
ఇబ్బందులను తాము పొందుటకు.

1328
00:58:11,920 --> 00:58:12,840
పరిమాణం ఎటువంటి పరిమితి.

1329
00:58:12,840 --> 00:58:14,940
మీరు ఏ సంఖ్య ఉంచవచ్చు
ఒక పట్టిక అంశాల.

1330
00:58:14,940 --> 00:58:17,620
ఒక వస్తువు యొక్క పరిమాణం
400 కిలోబైట్లు ప్రతి పరిమితం,

1331
00:58:17,620 --> 00:58:20,050
ఆ అంశం ఆపాదించాడు ఉంటుంది.

1332
00:58:20,050 --> 00:58:24,200
అన్ని గుణాలు మొత్తం సో
400 కిలోబైట్లు పరిమితమైంది.

1333
00:58:24,200 --> 00:58:27,300
ఆపై మళ్ళీ, మేము కలిగి
ఆ చిన్న LSI సమస్య

1334
00:58:27,300 --> 00:58:30,405
హాష్ 10 శాతం గిగాబైట్ పరిమితి.

1335
00:58:30,405 --> 00:58:33,280
ప్రేక్షకులు: చిన్న సంఖ్య, నేను లేదు నేను
ఏమి మీరు నాకు చెప్పుకుంటున్నారు is--

1336
00:58:33,280 --> 00:58:36,830
ప్రేక్షకులు: ఓహ్, 400 కిలోబైట్
అంశం ప్రతి గరిష్ట పరిమాణం.

1337
00:58:36,830 --> 00:58:39,570
కాబట్టి ఒక అంశం అన్ని లక్షణాలను కలిగి ఉంటుంది.

1338
00:58:39,570 --> 00:58:43,950
కాబట్టి 400 k మొత్తం పరిమాణం
ఆ అంశం యొక్క 400 కిలోబైట్లు.

1339
00:58:43,950 --> 00:58:46,170
అన్ని గుణాలను కాబట్టి
కలిపి, అన్ని డేటా

1340
00:58:46,170 --> 00:58:49,140
అన్ని ఆ లక్షణాలను వార్తలు,
మొత్తం పరిమాణం లోకి పైకి చుట్టుకొని,

1341
00:58:49,140 --> 00:58:51,140
ప్రస్తుతం నేడు అంశం పరిమితి 400 k ఉంది.

1342
00:58:51,140 --> 00:58:54,390

1343
00:58:54,390 --> 00:58:57,046
కాబట్టి సాధించవచ్చు, మళ్ళీ స్కేలింగ్
విభజనీకరణ ద్వారా.

1344
00:58:57,046 --> 00:58:58,920
నిర్గమాంశ కేటాయించినవి ఉంది
పట్టిక స్థాయిలో.

1345
00:58:58,920 --> 00:59:00,160
మరియు నిజంగా రెండు గుబ్బలు ఉంది.

1346
00:59:00,160 --> 00:59:02,400
మేము సామర్థ్యం చదివాను
మరియు సామర్థ్యం వ్రాయండి.

1347
00:59:02,400 --> 00:59:05,530
>> కాబట్టి ఈ సర్దుబాటు చేస్తారు
స్వతంత్రంగా ప్రతి ఇతర యొక్క.

1348
00:59:05,530 --> 00:59:08,640
RCU యొక్క కొలత ఖచ్చితంగా స్థిరమైన చదువుతుంది.

1349
00:59:08,640 --> 00:59:13,005
OK, కాబట్టి మీరు నేను 1,000 చెప్పడం చేస్తున్నారు
RCU యొక్క ఆ, ఖచ్చితంగా స్థిరంగా ఉంటాయి

1350
00:59:13,005 --> 00:59:14,130
ఆ స్థిరమైన చదువుతుంది ఉన్నాయి.

1351
00:59:14,130 --> 00:59:17,130
మీరు నేను అనుకుందాం ఉంటే
స్థిరమైన చివరకు, చదువుతుంది

1352
00:59:17,130 --> 00:59:19,402
మీరు సదుపాయం 1,000 చెయ్యవచ్చు
RCU యొక్క, మీరు చూడాలని

1353
00:59:19,402 --> 00:59:21,840
చివరికి 2,000 పొందడానికి
స్థిరమైన చదువుతుంది.

1354
00:59:21,840 --> 00:59:25,940
మరియు ఆ కోసం సగం ధర
చివరకు చదువుతుంది ఉంటాయి.

1355
00:59:25,940 --> 00:59:28,520
>> మళ్ళీ, సర్దుబాటు
స్వతంత్రంగా ప్రతి ఇతర యొక్క.

1356
00:59:28,520 --> 00:59:32,900
మరియు వారు throughput-- కలిగి
మీరు మీ RCU 100% తినే,

1357
00:59:32,900 --> 00:59:35,960
మీకు ప్రభావితం వెళ్ళడం లేదు చేస్తున్నాం
మీ హక్కులను లభ్యత.

1358
00:59:35,960 --> 00:59:40,161
కాబట్టి వారు పూర్తిగా ఉన్నాయి
ప్రతి ఇతర యొక్క స్వతంత్ర.

1359
00:59:40,161 --> 00:59:43,160
All right, కాబట్టి విషయాలు ఒకటి ఆ
నేను క్లుప్తంగా త్రొటిలింగ్ జరిగినది పేర్కొన్నారు.

1360
00:59:43,160 --> 00:59:44,320
త్రొటిలింగ్ చెడ్డది.

1361
00:59:44,320 --> 00:59:47,311
త్రొటిలింగ్ ఏ SQL చెడు సూచిస్తుంది.

1362
00:59:47,311 --> 00:59:50,310
మేము మీకు సహాయం చేయవచ్చు విషయాలను ఉన్నాయి
మీరు త్రొటిలింగ్ తగ్గించడానికి మీరు

1363
00:59:50,310 --> 00:59:51,040
ఎదుర్కొంటున్నాము.

1364
00:59:51,040 --> 00:59:53,240
కాని ఇది ఉత్తమ పరిష్కారం
ఈ యొక్క తీసుకుందాం ఉంది

1365
00:59:53,240 --> 00:59:58,000
ఎందుకంటే మీరు చేస్తున్న ఏమి చూడండి
ఇక్కడ నాటకంలో ఒక వ్యతిరేక నమూనా ఉంది.

1366
00:59:58,000 --> 01:00:02,140
>> ఈ విషయాలు, నాన్-యూనిఫామ్ వంటి విషయాలు
వర్కులోడ్సుకు వేడి కీలు, వేడి విభజనలు.

1367
01:00:02,140 --> 01:00:06,210
నేను ఒక నిర్దిష్ట కీ స్పేస్ నొక్కిన వెబ్
చాలా హార్డ్ కొన్ని ప్రత్యేక కారణం కోసం.

1368
01:00:06,210 --> 01:00:07,080
ఎందుకు నేను ఇలా చేస్తున్నాను?

1369
01:00:07,080 --> 01:00:08,710
ఆ గుర్తించడానికి అనుమతిస్తాయి.

1370
01:00:08,710 --> 01:00:10,427
నేను చల్లని డేటా నా వేడి డేటా మిక్సింగ్ చేస్తున్నాను.

1371
01:00:10,427 --> 01:00:12,510
నా పట్టికలు పొందుటకు తెలియజేసినందుకు చేస్తున్నాను
భారీ, కానీ నిజంగా ఉంది

1372
01:00:12,510 --> 01:00:15,970
డేటా మాత్రమే కొన్ని ఉపసమితి
నాకు నిజంగా ఆసక్తికరమైన ఉంది.

1373
01:00:15,970 --> 01:00:20,290
కాబట్టి లాగ్ డేటా కోసం, ఉదాహరణకు, చాలా
వినియోగదారులు, వారు ప్రతి రోజు డేటా లాగిన్ పొందండి.

1374
01:00:20,290 --> 01:00:22,490
వారు చిట్టా డేటా భారీ మొత్తం వచ్చింది.

1375
01:00:22,490 --> 01:00:25,940
>> మీరు అన్ని ఆ లాగ్ డంపింగ్ చేస్తుంటే
కాలక్రమేణా ఒక పెద్ద పట్టిక లోకి డేటా,

1376
01:00:25,940 --> 01:00:28,070
పట్టిక భారీ పొందడానికి జరగబోతోంది.

1377
01:00:28,070 --> 01:00:30,950
కానీ నేను నిజంగా మాత్రమే ఆసక్తి ఉన్నాను
గత 24 గంటలు, గత ఏడు రోజులు,

1378
01:00:30,950 --> 01:00:31,659
గత 30 రోజుల.

1379
01:00:31,659 --> 01:00:34,074
సమయం ఏది విండో
నేను చూస్తున్న ఆసక్తి ఉన్నాను

1380
01:00:34,074 --> 01:00:37,010
నాకు bothers, లేదా ఆ కార్యక్రమం కోసం
నాకు ఆసక్తికరంగా ఆ సంఘటన,

1381
01:00:37,010 --> 01:00:39,540
నేను అవసరం మాత్రమే విండో సమయం.

1382
01:00:39,540 --> 01:00:42,470
అందుచే నేను 10 సంవత్సరాల పెట్టటం చేస్తున్నాను
పట్టిక లాగ్ డేటా విలువ?

1383
01:00:42,470 --> 01:00:45,030
ఏం కారణమవుతోంది ఉంది
పట్టిక భాగం.

1384
01:00:45,030 --> 01:00:45,880
>> ఇది భారీ పొందుతాడు.

1385
01:00:45,880 --> 01:00:48,340
ఇది విస్తరించే మొదలవుతుంది
నోడ్స్ వేల అంతటా.

1386
01:00:48,340 --> 01:00:51,380
మరియు మీ సామర్థ్యం నుండి
మీరు ఉన్నాము, కాబట్టి తక్కువగా

1387
01:00:51,380 --> 01:00:54,090
నిజానికి ప్రతి పరిమితం రేట్
ఆ వ్యక్తి నోడ్స్ ఒకటి.

1388
01:00:54,090 --> 01:00:57,120
కాబట్టి యొక్క ఎలా చూడటం ప్రారంభిద్దాం
మేము పైగా ఆ పట్టిక రోల్ చేయండి.

1389
01:00:57,120 --> 01:01:01,502
మేము ఆ డేటా కొద్దిగా నిర్వహించడానికి ఎలా
బాగా ఈ సమస్యలను నివారించేందుకు.

1390
01:01:01,502 --> 01:01:02,710
మరియు ఆ చూడవచ్చు ఇష్టం లేదు?

1391
01:01:02,710 --> 01:01:04,370
ఈ ఆ కనిపిస్తుంది ఏమిటి.

1392
01:01:04,370 --> 01:01:06,790
ఈ చెడు NoSQL కనిపిస్తుంది ఏమిటి.

1393
01:01:06,790 --> 01:01:07,830
>> నేను ఇక్కడ ఒక వేడి కీ వచ్చింది.

1394
01:01:07,830 --> 01:01:10,246
మీరు ఇక్కడ వైపు చూస్తే,
ఈ అన్ని నా విభజనలు ఉన్నాయి.

1395
01:01:10,246 --> 01:01:12,630
నేను ఇక్కడ 16 విభజనలను లేచి
ఈ ప్రత్యేక డేటాబేస్.

1396
01:01:12,630 --> 01:01:13,630
మేము ఈ అన్ని మీకు.

1397
01:01:13,630 --> 01:01:15,046
నేను వినియోగదారుల కోసం అన్ని సమయం ఈ అమలు.

1398
01:01:15,046 --> 01:01:16,550
ఇది వేడి చిహ్నం అని.

1399
01:01:16,550 --> 01:01:20,590
హీట్ మాప్ మీరు ఎలా నాకు చెబుతుంది
మీ కీ స్పేస్ యాక్సెస్.

1400
01:01:20,590 --> 01:01:23,700
మరియు ఈ నాకు చెప్తుంటాడు ఉంది
ఒక నిర్దిష్ట హాష్ ఉందని

1401
01:01:23,700 --> 01:01:26,330
ఈ వ్యక్తి ఒక ఇష్టమని
భయంకర చాలా, అతను ఎందుకంటే

1402
01:01:26,330 --> 01:01:28,250
నిజంగా కష్టం, నిజంగా ఇది కొట్టిన.

1403
01:01:28,250 --> 01:01:29,260
>> కాబట్టి నీలం nice ఉంది.

1404
01:01:29,260 --> 01:01:29,900
మేము నీలం ఇష్టం.

1405
01:01:29,900 --> 01:01:30,720
మేము Red ఇష్టం లేదు.

1406
01:01:30,720 --> 01:01:33,120
Red యొక్క పేరు ఒత్తిడి
100% పైకి లేస్తుంది.

1407
01:01:33,120 --> 01:01:35,560
100%, ఇప్పుడు మీరు ఆపేసారు కావడం చేస్తున్నారు.

1408
01:01:35,560 --> 01:01:39,030
సో మీరు వంటి ఏ ఎరుపు పంక్తులు ఎప్పు
దీన్ని మరియు అది కేవలం డైనమో DB-- కాదు

1409
01:01:39,030 --> 01:01:41,630
ప్రతి NoSQL డేటాబేస్ ఈ సమస్య ఉంది.

1410
01:01:41,630 --> 01:01:44,640
యాంటి-పాటర్న్స్ చెయ్యవచ్చు ఉన్నాయి
పరిస్థితులు ఈ రకమైన డ్రైవ్.

1411
01:01:44,640 --> 01:01:49,070
నేను ఏమి నేను వినియోగదారులు పని ఉంది
ఈ పరిస్థితులు తగ్గించడానికి.

1412
01:01:49,070 --> 01:01:51,840
>> మరియు ఆ చూడవచ్చు ఇష్టం లేదు?

1413
01:01:51,840 --> 01:01:54,260
మరియు ఈ చాలా పెరిగిపోతుంది
డైనమో DB నిర్గమాంశ బయటకు,

1414
01:01:54,260 --> 01:01:56,176
కానీ అది నిజంగా సంతరించుకోనుంది
NoSQL అత్యంత బయటకు.

1415
01:01:56,176 --> 01:01:58,740
ఈ డైనమో పరిమితం కాదు.

1416
01:01:58,740 --> 01:02:02,050
ఈ definitely-- నేను
మొంగో వద్ద పని ఉపయోగిస్తారు.

1417
01:02:02,050 --> 01:02:04,090
నేను అనేక NoSQL వేదికల తెలిసిన రెడీ.

1418
01:02:04,090 --> 01:02:06,830
ప్రతి ఒకటి ఈ రకమైన ఉంది
వేడి కీ సమస్యలు.

1419
01:02:06,830 --> 01:02:10,320
ఏ NoSQL యొక్క మరింత పొందడానికి
డేటాబేస్, ప్రత్యేకంగా డైనమో DB,

1420
01:02:10,320 --> 01:02:13,320
మీరు పట్టికలు సృష్టించడానికి కావలసిన
పేరు హాష్ కీ మూలకం ఉంది

1421
01:02:13,320 --> 01:02:18,590
విలక్షణమైన విలువలు పెద్ద సంఖ్యలో,
ప్రాధాన్యతను యొక్క ఒక అధిక స్థాయి.

1422
01:02:18,590 --> 01:02:22,530
నేను వ్రాసే నేను అర్థం ఎందుకంటే
వివిధ బకెట్లు మా కు.

1423
01:02:22,530 --> 01:02:24,870
>> నేను మరింత బకెట్లు
, ఎక్కువగా వ్రాయడం

1424
01:02:24,870 --> 01:02:29,100
నేను ఆ రాసే బరువును విస్తరించడానికి am లేదా
బహుళ నోడ్లు మీదుగా బయటకు లోడ్ చదవండి,

1425
01:02:29,100 --> 01:02:33,560
ఎక్కువగా నేను ఒక కలిగి ఉన్నాను
పట్టిక అధిక నిర్గమాంశ.

1426
01:02:33,560 --> 01:02:37,440
ఆపై నేను విలువలు ఉండాలనుకుంటున్నాను
కాలక్రమంలో తగురీతిలో సమానంగా అభ్యర్థించిన

1427
01:02:37,440 --> 01:02:39,430
మరియు ఒకే విధంగా యాదృచ్చికంగా సాధ్యమైనంత.

1428
01:02:39,430 --> 01:02:42,410
అయితే, అది ఆసక్తికరమైన రకంగా
ఎందుకంటే నేను కాదు నిజంగా

1429
01:02:42,410 --> 01:02:43,960
నియంత్రణ వినియోగదారులు వచ్చినప్పుడు.

1430
01:02:43,960 --> 01:02:47,645
మేము వ్యాప్తి చేస్తే, చెప్పటానికి తగినంత
కీ స్పేస్ అంతటా విషయాలు బయటకు

1431
01:02:47,645 --> 01:02:49,270
మేము బహుశా మంచి ఆకారం లో ఉంటాం.

1432
01:02:49,270 --> 01:02:51,522
>> ఒక నిర్దిష్ట ఉంది
సమయం డెలివరీ మొత్తం

1433
01:02:51,522 --> 01:02:53,230
మీరు వెళుతున్న చేస్తున్నట్లు
సామర్థ్యం నియంత్రణ ఉండాలి.

1434
01:02:53,230 --> 01:02:55,438
కానీ ఆ నిజంగా
మేము కలిగి రెండు కొలతలు,

1435
01:02:55,438 --> 01:02:58,800
స్పేస్, యాక్సెస్ సమానంగా
స్ప్రెడ్, సమయం, అభ్యర్థనలు

1436
01:02:58,800 --> 01:03:01,040
సమానంగా సమయంలో ఖాళీకి చేరుకున్నాడు.

1437
01:03:01,040 --> 01:03:03,110
మరియు ఆ రెండు ఉంటే
షరతులకు చేస్తున్నారు,

1438
01:03:03,110 --> 01:03:05,610
అప్పుడు అంతే ఏమిటి
లాగా అన్నారు.

1439
01:03:05,610 --> 01:03:07,890
ఈ NICER ఉంది.

1440
01:03:07,890 --> 01:03:08,890
మేము ఇక్కడ నిజంగా సంతోషంగా ఉన్నారు.

1441
01:03:08,890 --> 01:03:10,432
మేము చాలా కూడా యాక్సెస్ నమూనా పొందారు.

1442
01:03:10,432 --> 01:03:13,098
అవును, బహుశా మీరు పొందుతుంటే ఒక
కొద్దిగా ఒత్తిడి ఇప్పుడు ఆపై ప్రతి,

1443
01:03:13,098 --> 01:03:14,830
కానీ ఏమీ నిజంగా చాలా విస్తృతమైన.

1444
01:03:14,830 --> 01:03:17,660
కనుక ఇది, ఎన్ని సార్లు ఆశ్చర్యంగా
నేను వినియోగదారులు పని చేసినప్పుడు,

1445
01:03:17,660 --> 01:03:20,670
పెద్ద ఎర్ర తో మొదటి గ్రాఫ్
బార్ మరియు అన్ని అది పసుపు వార్తలు అగ్లీ

1446
01:03:20,670 --> 01:03:23,147
అన్ని చోట్ల, మేము
వ్యాయామం పూర్తిచేశారని

1447
01:03:23,147 --> 01:03:24,980
నెలల తర్వాత
తిరిగి నిర్మాణ,

1448
01:03:24,980 --> 01:03:28,050
వారు ఖచ్చితమైన అదే అమలు చేస్తున్నారు
ఖచ్చితమైన లోడ్ వద్ద శ్రమను.

1449
01:03:28,050 --> 01:03:30,140
మరియు ఇది ఇప్పుడు వంటి ఆరాటపడుతుంది ఏమిటి.

1450
01:03:30,140 --> 01:03:36,600
సో వాట్ మీరు NoSQL తో పొందండి ఒక
ఖచ్చితంగా అని డేటా స్కీమా

1451
01:03:36,600 --> 01:03:38,510
యాక్సెస్ నమూనా ముడిపడి.

1452
01:03:38,510 --> 01:03:42,170
>> మరియు మీరు ఆ డేటా స్కీమా ఆప్టిమైజ్ చేయవచ్చు
ప్రాప్యత నమూనా మద్దతు.

1453
01:03:42,170 --> 01:03:45,490
మీరు లేకపోతే, అప్పుడు మీరు చూడాలని
సమస్యలు ఆ రకాల చూడండి

1454
01:03:45,490 --> 01:03:46,710
ఆ వేడి కీలు తో.

1455
01:03:46,710 --> 01:03:50,518
>> ప్రేక్షకులు: Well, అనివార్యంగా కొన్ని ప్రదేశాలలో
ఇతరుల కంటే వేడిగా ఉంటుంది వెళ్తున్నారు.

1456
01:03:50,518 --> 01:03:51,450
>> రిక్ HOULIHAN: ఎల్లప్పుడూ.

1457
01:03:51,450 --> 01:03:51,960
ఎల్లప్పుడూ.

1458
01:03:51,960 --> 01:03:54,620
అవును, నేను ఎల్లప్పుడూ ఉంది అర్థం
ఫంక్షన్ మరియు మళ్ళీ, ఉంది

1459
01:03:54,620 --> 01:03:56,980
కొన్ని డిజైన్ నమూనాలు మేము ద్వారా పొందుతారు
మీరు ఎదుర్కోవటానికి ఎలా గురించి చర్చ ఉంటుంది

1460
01:03:56,980 --> 01:03:58,480
ఈ సూపర్ పెద్ద aggregations తో.

1461
01:03:58,480 --> 01:04:01,260
నా ఉద్దేశ్యం, నేను వాటిని కలిగి వచ్చింది
మేము వారితో ఎలా ఒప్పందం చేసుకోవాలి?

1462
01:04:01,260 --> 01:04:03,760
నేను ఒక అందమైన మంచి ఉపయోగం విషయంలో వచ్చింది
మేము ఆ కోసం గురించి మాట్లాడదాము.

1463
01:04:03,760 --> 01:04:05,940
>> All right, కాబట్టి లెట్స్ చర్చ
ఇప్పుడు గురించి కొన్ని వినియోగదారులు.

1464
01:04:05,940 --> 01:04:06,950
ఈ అబ్బాయిలు AdRoll ఉన్నాయి.

1465
01:04:06,950 --> 01:04:08,990
మీరు అయితే నాకు తెలీదు
AdRoll తెలిసిన.

1466
01:04:08,990 --> 01:04:10,781
మీరు బహుశా వాటిని చూడండి
బ్రౌజర్లో చాలా.

1467
01:04:10,781 --> 01:04:14,230
వారు ఉన్నారు, ప్రకటన తిరిగి లక్ష్యంగా చేస్తున్న
అతిపెద్ద ప్రకటన రీ-లక్ష్య వ్యాపార

1468
01:04:14,230 --> 01:04:14,940
అక్కడ.

1469
01:04:14,940 --> 01:04:17,792
వారు సాధారణంగా క్రమం తప్పకుండా పరిగెత్తే
రోజుకు 60 బిలియన్ల లావాదేవీలను.

1470
01:04:17,792 --> 01:04:20,000
వారు ఒక మిలియన్ పైగా చేస్తున్నా
సెకనుకు లావాదేవీలు.

1471
01:04:20,000 --> 01:04:22,660
వారు ఒక అందమైన సాధారణ పట్టిక పొందారు
నిర్మాణం, రద్దీ పట్టిక.

1472
01:04:22,660 --> 01:04:26,450
ఇది ప్రాథమికంగా కేవలం
హాష్ కీ, కుకీ

1473
01:04:26,450 --> 01:04:29,010
పరిధి జనాభా ఉంది
వర్గం, మరియు అప్పుడు

1474
01:04:29,010 --> 01:04:31,220
మూడవ లక్షణం స్కోరు.

1475
01:04:31,220 --> 01:04:33,720
>> కాబట్టి మేము అన్ని కుక్కీలను కలిగి
ఈ కుర్రాళ్ళు నుండి మా బ్రౌజర్.

1476
01:04:33,720 --> 01:04:35,900
మరియు మీరు ఒక వెళ్ళేటప్పుడు
వ్యాపారి పాల్గొనే,

1477
01:04:35,900 --> 01:04:39,390
ఇవి ప్రధానంగా అంతటా మీరు స్కోర్
వివిధ జనాభా వర్గాలు.

1478
01:04:39,390 --> 01:04:42,070
మీరు ఒక వెబ్ సైట్ కు వెళ్ళేటప్పుడు మరియు
మీరు నేను ఈ ad-- చూడండి అనుకుందాం

1479
01:04:42,070 --> 01:04:44,920
లేదా ప్రాథమికంగా మీరు ఆ చెప్పటానికి లేదు
కానీ మీరు వెబ్సైట్ వెళ్ళేటప్పుడు

1480
01:04:44,920 --> 01:04:47,550
వారు మీరు ఈ ప్రకటనను చూడటానికి అనుకుందాం.

1481
01:04:47,550 --> 01:04:49,370
మరియు వారు AdRoll నుండి ప్రకటన పొందండి వెళ్ళండి.

1482
01:04:49,370 --> 01:04:51,130
AdRoll వారి పట్టిక మీరు చూస్తుంది.

1483
01:04:51,130 --> 01:04:52,115
వారు మీ కుకీ కనుగొనేందుకు.

1484
01:04:52,115 --> 01:04:53,990
చెప్పడం ప్రకటనదారులు
వాటిని నేను ఎవరైనా కావలసిన

1485
01:04:53,990 --> 01:04:58,632
ఎవరు, మధ్య వయస్కులు వార్తలు
క్రీడలు లోకి 40 ఏళ్ల వ్యక్తి చెప్పారు.

1486
01:04:58,632 --> 01:05:01,590
మరియు వారు ఆ జనాభా మీరు స్కోర్
మరియు వారు కాదో నిర్ణయించటానికి

1487
01:05:01,590 --> 01:05:02,740
మీరు ఒక మంచి ప్రకటన ఉంది.

1488
01:05:02,740 --> 01:05:10,330
>> ఇప్పుడు వారు ఒక SLA కలిగి
వారి ప్రకటనల ప్రొవైడర్స్

1489
01:05:10,330 --> 01:05:14,510
సబ్ -10 మిల్లిసెకనులో అందించడానికి
ప్రతి ఒక్క అభ్యర్థన న స్పందన.

1490
01:05:14,510 --> 01:05:16,090
కాబట్టి వారు ఈ డైనమో DB ఉపయోగిస్తున్నారు.

1491
01:05:16,090 --> 01:05:18,131
వారు మాకు కొట్టిన చేస్తున్నారు
సెకనుకు మిలియన్ అభ్యర్థనలు.

1492
01:05:18,131 --> 01:05:21,120
వారు అన్ని చేస్తామని ఉన్నారు వారి
అన్వేషణలను, చిక్సితకు ఆ డేటా,

1493
01:05:21,120 --> 01:05:26,130
మరియు ఆ తిరిగి ఆ జోడించండి లింకు
10 మిల్లీ కింద ప్రకటనదారు.

1494
01:05:26,130 --> 01:05:29,800
ఇది నిజంగా అందంగా అసాధారణంగా ఉంది
అమలు వారు కలిగి.

1495
01:05:29,800 --> 01:05:36,210
>> ఈ అబ్బాయిలు నిజానికి
అబ్బాయిలు ఇవి.

1496
01:05:36,210 --> 01:05:38,010
నేను ఈ కుర్రాళ్ళు ఉంటే ఖచ్చితంగా తెలియదు.

1497
01:05:38,010 --> 01:05:40,127
ఈ కుర్రాళ్ళు కావచ్చు.

1498
01:05:40,127 --> 01:05:42,210
సాధారణంగా నేను, ఏ us-- చెప్పారు
అది వారికి ఉంది భావించడం లేదు.

1499
01:05:42,210 --> 01:05:43,000
నేను మరొకరి భావించాను.

1500
01:05:43,000 --> 01:05:44,750
నేను ఒక పని
కస్టమర్ నాకు చెప్పారు ఆ

1501
01:05:44,750 --> 01:05:47,040
ఇప్పుడు అవి చేసిన
డైనమో DB వెళ్ళిన వారు ఉన్నారు

1502
01:05:47,040 --> 01:05:50,330
కోసం స్నాక్స్ మరింత డబ్బు ఖర్చు
వారి అభివృద్ధి జట్టులో ప్రతి నెల

1503
01:05:50,330 --> 01:05:52,886
వారు వారి డేటాబేస్ ఖర్చు కంటే.

1504
01:05:52,886 --> 01:05:54,760
కనుక ఇది మీరు ఒక ఇస్తాము
పొదుపు ఆలోచన

1505
01:05:54,760 --> 01:05:57,889
మీరు డైనమో DB లో పొందవచ్చు భారీ ఉంది.

1506
01:05:57,889 --> 01:05:59,430
అన్ని కుడి, dropcam మరొక కంపెనీ ఇది.

1507
01:05:59,430 --> 01:06:02,138
ఈ వ్యక్తి రకమైన of-- మీరు అనుకుంటే వార్తలు
థింగ్స్ ఇంటర్నెట్, dropcam యొక్క

1508
01:06:02,138 --> 01:06:05,150
ప్రధానంగా ఇంటర్నెట్ భద్రతా వీడియో.

1509
01:06:05,150 --> 01:06:06,660
మీరు అక్కడ మీ కెమెరా బయటకు చాలు.

1510
01:06:06,660 --> 01:06:08,180
కెమెరా ఒక చలన శోధన ఉంది.

1511
01:06:08,180 --> 01:06:10,290
ఎవరో, వెంట వస్తుంది
ఒక క్యూ పాయింట్ వస్తుంది.

1512
01:06:10,290 --> 01:06:13,540
కెమెరా కాసేపు వరకు రికార్డింగ్ మొదలవుతుంది
అది ఇకపై ఏ మోషన్ గుర్తించడం లేదు.

1513
01:06:13,540 --> 01:06:15,310
ఇంటర్నెట్ లో ఆ వీడియో అప్ ఉంచుతుంది.

1514
01:06:15,310 --> 01:06:19,800
>> Dropcam అని ఒక సంస్థ
ప్రధానంగా డైనమో DB మొగ్గు

1515
01:06:19,800 --> 01:06:22,200
అవి ఎదుర్కొంటున్న ఎందుకంటే
అపారమైన గ్రోయింగ్ పెయిన్స్.

1516
01:06:22,200 --> 01:06:25,820
మరియు వారు మాకు చెప్పారు,
హఠాత్తుగా డేటా petabytes.

1517
01:06:25,820 --> 01:06:28,070
వారు ఆలోచన వారి సేవ కలిగి
కాబట్టి విజయవంతం అవుతుంది.

1518
01:06:28,070 --> 01:06:32,310
YouTube కంటే మరింత లను వీడియో
ఈ కుర్రాళ్ళు పొందడానికి ఏమి ఉంది.

1519
01:06:32,310 --> 01:06:36,780
వారు అన్ని ట్రాక్ DynamoDB ఉపయోగించడానికి
అన్ని వారి వీడియో కీలక అంశాలపై మెటాడేటా.

1520
01:06:36,780 --> 01:06:40,282
>> కాబట్టి వారు పుష్ ఎస్ 3 బకెట్లు
అన్ని బైనరీ కళాఖండాల లోకి.

1521
01:06:40,282 --> 01:06:41,990
ఆపై వారు కలిగి
డైనమో DB రికార్డులు

1522
01:06:41,990 --> 01:06:44,070
ఆ S3 మూడు వస్తువులు ప్రజలు అభిప్రాయపడుతున్నారు.

1523
01:06:44,070 --> 01:06:47,070
వారు ఒక వీడియో వద్ద చూడవలసిన అవసరం ఉన్నప్పుడు,
వారు డైనమో DB లో రికార్డు వెతకండి.

1524
01:06:47,070 --> 01:06:47,903
వారు లింక్ క్లిక్ చేయండి.

1525
01:06:47,903 --> 01:06:49,770
వారు S3 నుండి వీడియో డౌన్ లాగండి.

1526
01:06:49,770 --> 01:06:51,590
కాబట్టి ఈ కనిపిస్తుంది ఏమి యొక్క ఉంటాము.

1527
01:06:51,590 --> 01:06:53,580
మరియు ఈ వారి జట్టు నుండి నేరుగా ఉంది.

1528
01:06:53,580 --> 01:06:56,010
>> డైనమో DB వారి తగ్గిస్తుంది
వీడియో సంఘటనలు బట్వాడా సమయం

1529
01:06:56,010 --> 01:06:57,590
ఐదు నుంచి 10 సెకన్ల నుంచి.

1530
01:06:57,590 --> 01:07:00,470
వారి పాత రిలేషనల్ స్టోర్ లో,
వారు వెళ్లి అమలు చేయాలి ఉపయోగిస్తారు

1531
01:07:00,470 --> 01:07:03,780
ఫిగర్ బహుళ క్లిష్టమైన ప్రశ్నలు
ఇది బయటకు వీడియోలు, లాగేందుకు

1532
01:07:03,780 --> 01:07:06,690
కంటే తక్కువ 50 మిల్లీసెకన్లు.

1533
01:07:06,690 --> 01:07:08,990
కాబట్టి ఇది అద్భుతమైన, అద్భుతమైన వార్తలు
ఎంత పనితీరు

1534
01:07:08,990 --> 01:07:12,990
మీరు ఆప్టిమైజ్ మీరు పొందవచ్చు మరియు
మీరు ట్యూన్ అంతర్లీన డేటాబేస్

1535
01:07:12,990 --> 01:07:15,110
యాక్సెస్ నమూనా మద్దతు.

1536
01:07:15,110 --> 01:07:20,500
అది ఏమిటో Halfbrick, ఈ కుర్రాళ్ళు,
నేను ఊహిస్తున్నాను ఫ్రూట్ నింజా వారి విషయం.

1537
01:07:20,500 --> 01:07:22,590
డైనమో DB అన్ని నడుస్తుంది.

1538
01:07:22,590 --> 01:07:26,810
మరియు ఈ అబ్బాయిలు, వారు గొప్ప ఉంటాయి
అభివృద్ధి బృందం, గొప్ప అభివృద్ధి

1539
01:07:26,810 --> 01:07:27,670
షాప్.

1540
01:07:27,670 --> 01:07:29,364
>> ఒక మంచి ఆప జట్టు.

1541
01:07:29,364 --> 01:07:31,280
వారు చాలా లేదు
ఆపరేషన్ వనరుల.

1542
01:07:31,280 --> 01:07:33,940
వారు ఉంచడానికి ప్రయత్నిస్తున్న పోరాడుతున్న
వారి అప్లికేషన్ మౌలిక సదుపాయాలు

1543
01:07:33,940 --> 01:07:34,290
మరియు రన్నింగ్.

1544
01:07:34,290 --> 01:07:35,000
వారు మాకు వచ్చింది.

1545
01:07:35,000 --> 01:07:36,251
వారు డైనమో DB చూశారు.

1546
01:07:36,251 --> 01:07:37,291
వారు మాకు ఆ వార్తలు అన్నారు.

1547
01:07:37,291 --> 01:07:39,470
వారు వారి మొత్తం నిర్మించిన
దానిపై అప్లికేషన్ ఫ్రేమ్వర్క్.

1548
01:07:39,470 --> 01:07:43,640
ఇక్కడ కొన్ని నిజంగా nice వ్యాఖ్యలు
వారి సామర్థ్యంపై జట్టు నుండి

1549
01:07:43,640 --> 01:07:46,800
ఇప్పుడు భవనం పై దృష్టి
ఆట మరియు

1550
01:07:46,800 --> 01:07:49,010
నిర్వహించాల్సిన అవసరం
అవస్థాపన, ఇది

1551
01:07:49,010 --> 01:07:51,910
అపరిమిత కాసాగారు
వారి జట్టు కోసం భారాన్ని.

1552
01:07:51,910 --> 01:07:56,170
కాబట్టి ఈ విషయం ఆ
మీరు డైనమో DB నుండి పొందండి ప్రయోజనం.

1553
01:07:56,170 --> 01:08:00,930
>> అన్ని కుడి, రావడము
ఇక్కడ డేటా మోడలింగ్.

1554
01:08:00,930 --> 01:08:03,440
మేము గురించి కొద్దిగా మాట్లాడారు
ఒకటి ఈ ఒకటి, అనేక ఒకటి,

1555
01:08:03,440 --> 01:08:05,060
మరియు అనేక రకం సంబంధాలు అనేక.

1556
01:08:05,060 --> 01:08:07,630
మరియు ఎలా మీరు డైనమో ఆ కొనసాగించటానికి లేదు.

1557
01:08:07,630 --> 01:08:10,500
డైనమో DB లో మేము ఉపయోగించే
సూచికలు సాధారణంగా మాట్లాడటం,

1558
01:08:10,500 --> 01:08:12,910
నుండి డేటా రొటేట్
ఇతర ఒక రుచి.

1559
01:08:12,910 --> 01:08:15,210
హాష్ కీలను, పరిధి కీలు, మరియు ఇండెక్సులు.

1560
01:08:15,210 --> 01:08:18,540
>> ఈ ముఖ్యంగా
ఉదాహరణకు, అనేక రాష్ట్రాలు

1561
01:08:18,540 --> 01:08:23,802
ఒక లైసెన్సింగ్ అవసరాలే ఉన్నాయో ఆ
తలకు మాత్రమే ఒక డ్రైవర్ లైసెన్స్.

1562
01:08:23,802 --> 01:08:26,510
మీరు రెండు డ్రైవర్ పొందడానికి వెళ్ళి కాదు
బోస్టన్ రాష్ట్రంలో లైసెన్సుల.

1563
01:08:26,510 --> 01:08:27,500
నేను టెక్సాస్ లో అది చెయ్యలేరు.

1564
01:08:27,500 --> 01:08:28,708
ఆ ఇది మార్గం రకంగా.

1565
01:08:28,708 --> 01:08:32,779
కాబట్టి DMV వద్ద, మేము అన్వేషణలను కలిగి, మేము
డ్రైవర్ యొక్క లైసెన్స్ చూసేందుకు మీరు

1566
01:08:32,779 --> 01:08:35,180
సామాజిక భద్రతా సంఖ్య ద్వారా.

1567
01:08:35,180 --> 01:08:39,990
నేను యూజర్ వివరాలు చూసేందుకు మీరు
డ్రైవర్ యొక్క లైసెన్స్ సంఖ్యను ద్వారా.

1568
01:08:39,990 --> 01:08:43,620
>> కాబట్టి మేము ఒక వినియోగదారు యొక్క పట్టిక కలిగి ఉండవచ్చని
క్రమ సంఖ్య లో ఒక హాష్ కీ ఉంది,

1569
01:08:43,620 --> 01:08:47,830
లేదా సామాజిక భద్రతా సంఖ్య, మరియు
వివిధ గుణాలను అంశంపై నిర్వచించింది.

1570
01:08:47,830 --> 01:08:49,859
ఇప్పుడు ఆ పట్టిక నేను
ఒక GSI నిర్వచించే అని

1571
01:08:49,859 --> 01:08:53,370
చెప్పారు చుట్టూ నేను కావలసిన ఎగరవేసిన ప్రతిసారి
అప్పుడు లైసెన్స్ మరియు ఒక హాష్ కీ

1572
01:08:53,370 --> 01:08:54,252
అన్ని ఇతర అంశాలను.

1573
01:08:54,252 --> 01:08:57,210
ఇప్పుడు నేను ప్రశ్నించడానికి కనుగొనేందుకు కావాలా
ఇచ్చిన ఏ సోషల్ కోసం లైసెన్స్ సంఖ్య

1574
01:08:57,210 --> 01:08:59,609
సెక్యూరిటీ నంబర్, నేను
ప్రధాన పట్టిక విచారించారు.

1575
01:08:59,609 --> 01:09:02,130
>> నేను ప్రశ్నించడానికి కావలసిన మరియు నేను అనుకుంటే
సామాజిక భద్రత పొందడానికి

1576
01:09:02,130 --> 01:09:05,735
నంబరు లేదా ఇతర లక్షణాలను
లైసెన్స్ సంఖ్య, నేను GSI ప్రశ్నించడానికి.

1577
01:09:05,735 --> 01:09:08,689
ఆ నమూనా ఒకటి
ఒక సంబంధానికి.

1578
01:09:08,689 --> 01:09:12,460
జస్ట్ చాలా సాధారణ GSI,
చుట్టూ ఆ విషయాలు కుదుపు.

1579
01:09:12,460 --> 01:09:13,979
ఇప్పుడు, అనేక గురించి చర్చ.

1580
01:09:13,979 --> 01:09:16,450
అనేక ఒక రప్పించింది
మీ హాష్ పరిధి కీ.

1581
01:09:16,450 --> 01:09:20,510
మేము ఈ చాలా చోటే
ఉపయోగం విషయంలో మానిటర్ డేటా.

1582
01:09:20,510 --> 01:09:23,880
మానిటర్ డేటా రెగ్యులర్ వస్తుంది
విషయాలు ఇంటర్నెట్ వంటి విరామం.

1583
01:09:23,880 --> 01:09:26,890
మేము ఎల్లప్పుడూ అన్ని ఈ పొందుటకు
రికార్డులు అన్ని సమయం లో వస్తోంది.

1584
01:09:26,890 --> 01:09:31,420
>> మరియు నేను అన్ని రీడింగులను కనుగొనడానికి కావలసిన
నిర్ణీత కాలం మధ్య.

1585
01:09:31,420 --> 01:09:34,220
ఇది చాలా సాధారణమైన ప్రశ్న వార్తలు
పర్యవేక్షణ అవస్థాపన.

1586
01:09:34,220 --> 01:09:38,430
గురించి మార్గం ప్రయాణంలో ఒక గుర్తించడం
సాధారణ పట్టిక నిర్మాణం ఒక పట్టిక.

1587
01:09:38,430 --> 01:09:42,250
నేను ఒక పరికరం కొలతలు పట్టిక పొందారు
పరికర ఐడి ఒక హాష్ కీతో.

1588
01:09:42,250 --> 01:09:47,340
మరియు నేను ఒక పరిధి కీ
స్టాంప్, లేదా ఈ సందర్భంలో, పురాణ.

1589
01:09:47,340 --> 01:09:50,350
మరియు నాకు క్లిష్టమైన అమలు అనుమతిస్తుంది
ఆ పరిధిలో కీ వ్యతిరేకంగా ప్రశ్నలు

1590
01:09:50,350 --> 01:09:54,950
మరియు ఆ రికార్డులను తిరిగి
ఫలితంగా వాటికి సాపేక్షంగా

1591
01:09:54,950 --> 01:09:56,310
నేను చూస్తున్నాను సెట్.

1592
01:09:56,310 --> 01:09:58,360
మరియు దానిని ఒక ఆధారమై
అనేక సంబంధానికి

1593
01:09:58,360 --> 01:10:02,340
ఉపయోగించి ప్రాథమిక పట్టిక లోకి
హాష్ కీ, పరిధి కీ నిర్మాణం.

1594
01:10:02,340 --> 01:10:04,600
>> కాబట్టి ఆ రకమైన నిర్మించిన
డైనమో DB పట్టిక లోకి.

1595
01:10:04,600 --> 01:10:07,290
నేను ఒక హాష్ నిర్వచించే సమయంలో
మరియు పరిధి t పట్టిక, నేను రెడీ

1596
01:10:07,290 --> 01:10:09,240
అనేక సంబంధానికి ఒక నిర్వచించు.

1597
01:10:09,240 --> 01:10:12,770
ఇది ఒక తల్లితండ్రుల-పిల్లల సంబంధం ఉంది.

1598
01:10:12,770 --> 01:10:14,620
>> యొక్క అనేక గురించి మాట్లాడేందుకు లెట్
అనేక సంబంధాలు.

1599
01:10:14,620 --> 01:10:19,170
మరియు ఈ ప్రత్యేక ఉదాహరణకు,
మళ్ళీ, మేము GSI యొక్క ఉపయోగించడానికి వెళుతున్న.

1600
01:10:19,170 --> 01:10:23,500
మరియు యొక్క గేమింగ్ గురించి మాట్లాడటానికి వీలు
నేను ఇచ్చిన యూజర్ పేరు దృష్టాంతంలో.

1601
01:10:23,500 --> 01:10:26,500
నేను అన్ని గేమ్స్ కనుగొనేందుకు కావలసిన
అతను లేదా ఆడుతున్న నమోదు యొక్క.

1602
01:10:26,500 --> 01:10:29,600
మరియు ఇచ్చిన ఆట కోసం, నేను
అన్ని వినియోగదారులు కావలసిన.

1603
01:10:29,600 --> 01:10:31,010
సో ఎలా నేను ఆ చేయాలి?

1604
01:10:31,010 --> 01:10:34,330
నా యూజర్ ఆటలు పట్టిక, నేను వెళుతున్నాను
యూజర్ ID ఒక హాష్ కీ కలిగి

1605
01:10:34,330 --> 01:10:35,810
మరియు ఆట యొక్క ఒక పరిధి కీ.

1606
01:10:35,810 --> 01:10:37,810
>> కాబట్టి ఒక వినియోగదారు పలు ఆటలను కలిగి ఉంటుంది.

1607
01:10:37,810 --> 01:10:41,380
ఇది మధ్య అనేక సంబంధం ఒక ఒకటి
వినియోగదారు మరియు అతను పోషిస్తుంది గేమ్స్.

1608
01:10:41,380 --> 01:10:43,410
ఆపై GSI లో,
నేను ఆ చుట్టూ కుదుపు చేస్తాము.

1609
01:10:43,410 --> 01:10:46,679
నేను గేమ్ లో హాష్ చేస్తాము మరియు
నేను యూజర్ పరిధిపై చేస్తాము.

1610
01:10:46,679 --> 01:10:48,970
నేను అన్ని పొందాలనుకోవడం చేస్తే
గేమ్ యూజర్ యొక్క ఆడుతున్న,

1611
01:10:48,970 --> 01:10:49,950
నేను ప్రధాన పట్టిక ప్రశ్నించడానికి చేస్తాము.

1612
01:10:49,950 --> 01:10:52,699
నేను అన్ని వినియోగదారులు పొందడానికి అనుకుంటే
ఒక నిర్దిష్ట గేమ్ ప్లే,

1613
01:10:52,699 --> 01:10:53,887
నేను GSI విచారించారు.

1614
01:10:53,887 --> 01:10:54,970
కాబట్టి మీరు మేము దీన్ని ఎలా?

1615
01:10:54,970 --> 01:10:58,369
మీరు ఈ GSI యొక్క మద్దతు నిర్మించడానికి
ఉపయోగం విషయంలో, అప్లికేషన్, యాక్సెస్

1616
01:10:58,369 --> 01:10:59,410
నమూనా, అప్లికేషన్.

1617
01:10:59,410 --> 01:11:01,440
>> నేను ప్రశ్నించడానికి అవసరం అయితే
ఈ కోణంలో, వీలు

1618
01:11:01,440 --> 01:11:03,500
నాకు ఆ కోణాన్ని మీద ఇండెక్స్ సృష్టించడానికి.

1619
01:11:03,500 --> 01:11:05,850
నేను లేకపోతే, నేను పట్టించుకోను.

1620
01:11:05,850 --> 01:11:09,060
మరియు ఉపయోగం కేసు ఆధారంగా, నేను
సూచిక అవసరం లేదా నేను ఉండకపోవచ్చు.

1621
01:11:09,060 --> 01:11:12,390
ఇది ఒక సాధారణ ఎందఱో వార్తలు ఉంటే,
ప్రాథమిక పట్టిక జరిమానా ఉంది.

1622
01:11:12,390 --> 01:11:15,860
నేను ఈ అనేక చెయ్యాల్సిన ఉంటే
అనేక యొక్క, లేదా నేను వాటిని ఒకటి చెయ్యాల్సిన

1623
01:11:15,860 --> 01:11:18,390
అప్పుడు బహుశా నేను చేయాలి
రెండవ ఇండెక్స్.

1624
01:11:18,390 --> 01:11:20,840
కనుక ఇది అన్ని ఆధారపడి
నేను ఏమి దీనికై

1625
01:11:20,840 --> 01:11:24,550
మరియు నేను నిష్ణాత పొందడానికి దీనికై ఏమి.

1626
01:11:24,550 --> 01:11:28,000
>> బహుశా నేను చాలా ఖర్చు వెళుతున్న కాదు
ఎక్కువ సమయం పత్రాలు గురించి మాట్లాడటం.

1627
01:11:28,000 --> 01:11:31,460
ఈ బహుశా, కొద్దిగా గెట్స్
లోతుగా మేము లోకి వెళ్ళడానికి అవసరం కంటే.

1628
01:11:31,460 --> 01:11:33,710
యొక్క కొద్దిగా చర్చ లెట్
సంపన్నులు ప్రశ్న వ్యక్తీకరణ.

1629
01:11:33,710 --> 01:11:37,831
డైనమో DB లో మేము కలిగి
సృష్టించే సామర్థ్యం

1630
01:11:37,831 --> 01:11:39,330
మేము ప్రొజెక్షన్ వ్యక్తీకరణలు కాల్ ఏమి.

1631
01:11:39,330 --> 01:11:42,660
ప్రొజెక్షన్ వ్యక్తీకరణలు కేవలం ఉన్నాయి
ఖాళీలను లేదా విలువలు తయారయ్యారు

1632
01:11:42,660 --> 01:11:44,290
మీరు ప్రదర్శించడానికి కావలసిన.

1633
01:11:44,290 --> 01:11:46,000
OK, కాబట్టి నేను ఒక ఎంపిక చేయడానికి.

1634
01:11:46,000 --> 01:11:48,010
నేను డైనమో DB వ్యతిరేకంగా ఒక ప్రశ్న తయారు.

1635
01:11:48,010 --> 01:11:51,730
నేను మీరు చూపించు ఏమి చెప్పేది
నాకు మాత్రమే ఐదు నక్షత్రాల సమీక్షలను

1636
01:11:51,730 --> 01:11:54,544
ఈ ప్రత్యేక ఉత్పత్తి కోసం.

1637
01:11:54,544 --> 01:11:55,710
కాబట్టి ఆ నేను చూడాలనుకుంటే అంతే.

1638
01:11:55,710 --> 01:11:57,320
నేను అన్ని చూడాలనుకుంటే లేదు
వరుసగా ఇతర లక్షణాలను,

1639
01:11:57,320 --> 01:11:58,319
నేను ఈ చూడాలనుకుంటే.

1640
01:11:58,319 --> 01:12:01,209
ఇది కేవలం ఉన్నప్పుడు SQL లో వంటిది మీరు
ఎంపిక స్టార్ లేదా పట్టిక నుండి చెప్పటానికి,

1641
01:12:01,209 --> 01:12:02,000
మీరు ప్రతిదీ పొందండి.

1642
01:12:02,000 --> 01:12:05,450
నేను నుండి select name చెప్పినప్పుడు
పట్టిక, నేను మాత్రమే ఒక లక్షణం.

1643
01:12:05,450 --> 01:12:09,070
ఇది విషయం అదే రకమైన వార్తలు
డైనమో DB లేదా మరొక NoSQL డేటాబేస్.

1644
01:12:09,070 --> 01:12:14,510
వడపోత వ్యక్తీకరణలు నాకు అనుమతిస్తాయి
ప్రధానంగా డౌన్ సెట్ ఫలితంగా కట్.

1645
01:12:14,510 --> 01:12:15,540
నేను ఒక ప్రశ్న తయారు.

1646
01:12:15,540 --> 01:12:17,260
ప్రశ్నా 500 వస్తువులను తిరిగి రావచ్చు.

1647
01:12:17,260 --> 01:12:20,255
కానీ నేను మాత్రమే అంశాలను కావలసిన
ఈ అని ఒక లక్షణం కలిగి.

1648
01:12:20,255 --> 01:12:23,380
OK, కాబట్టి యొక్క ఆ అంశాలను ఫిల్టర్ వీలు
ఆ నిర్దిష్ట ప్రశ్న సరిపోలడం లేదు.

1649
01:12:23,380 --> 01:12:25,540
కాబట్టి మేము వడపోత భావాలు ఉన్నాయి.

1650
01:12:25,540 --> 01:12:28,310
>> వడపోత వ్యక్తీకరణలు చెయ్యవచ్చు
ఏ లక్షణం అమలు.

1651
01:12:28,310 --> 01:12:30,260
వారు పరిధి ప్రశ్నలకు వంటి లేదు.

1652
01:12:30,260 --> 01:12:32,690
రైజ్ ప్రశ్నలు మరింత ప్రత్యేకమైనవి.

1653
01:12:32,690 --> 01:12:36,470
వడపోత ప్రశ్నలు వెళ్ళడానికి నాకు అవసరం
మొత్తం ఫలితాలు సెట్ చేసుకోగా

1654
01:12:36,470 --> 01:12:39,170
నేను వద్దు డేటా కోరుకుంటాయి.

1655
01:12:39,170 --> 01:12:40,660
ఎందుకు ముఖ్యం?

1656
01:12:40,660 --> 01:12:42,770
నేను అన్ని చదివి ఎందుకంటే.

1657
01:12:42,770 --> 01:12:46,597
ఒక ప్రశ్న, నేను చదివిన వెళుతున్న మరియు
ఇది డేటా గురించి ఒక పెద్ద చేస్తాడు.

1658
01:12:46,597 --> 01:12:48,430
ఆపై నేను వెళుతున్నాను
నేను అవసరం ఏమి కోరుకుంటాయి.

1659
01:12:48,430 --> 01:12:52,080
మరియు నేను మాత్రమే చెక్కటానికి వెబ్ ఉంటే ఒక
వరుసల జంట, అప్పుడు ఆ సరే.

1660
01:12:52,080 --> 01:12:53,620
ఇది మరింత అసమర్థంగా కాదు.

1661
01:12:53,620 --> 01:12:57,800
>> కానీ నేను యొక్క మొత్తం కుప్ప వింటున్నాను ఉంటే
డేటా, కేవలం ఒక అంశాన్ని కోరుకుంటాయి

1662
01:12:57,800 --> 01:13:01,490
అప్పుడు నేను మంచి ఉండాలి వెళుతున్నాను
ఒక పరిధి ప్రశ్న ఉపయోగించి ఆఫ్,

1663
01:13:01,490 --> 01:13:03,030
ఇది చాలా సెలెక్టివ్ ఎందుకంటే.

1664
01:13:03,030 --> 01:13:06,330
ఇది నాకు చాలా సేవ్ జరగబోతోంది
డబ్బు, నేను చదవడానికి చెల్లించాల్సిన ఎందుకంటే.

1665
01:13:06,330 --> 01:13:10,430
ఎక్కడ తిరిగి వచ్చే ఫలితాలు
చిన్న కావచ్చు, ఆ తీగ దాటి,

1666
01:13:10,430 --> 01:13:11,890
కానీ నేను చదివినవి చెల్లిస్తున్న చేస్తున్నాను.

1667
01:13:11,890 --> 01:13:14,340
సో ఎలా అర్థం
మీరు డేటా పొందుతుంటే.

1668
01:13:14,340 --> 01:13:16,420
ఆ డైనమో DB లో చాలా ముఖ్యం.

1669
01:13:16,420 --> 01:13:19,710
>> షరతులతో వ్యక్తీకరణలు, ఈ ఏమి ఉంది
మీరు ఆశావాద లాకింగ్ కాల్ ఉండవచ్చు.

1670
01:13:19,710 --> 01:13:28,470
నవీకరణ ఏర్పడుతుంది, లేదా ఈ విలువ ఉంటే
నేను పేర్కొన్న ఏమి సమానం.

1671
01:13:28,470 --> 01:13:31,494
నేను ఒక ఒక సమయం స్టాంప్ ఉంటే
రికార్డు, నిజంగా నేను డేటా చదవండి ఉండవచ్చు.

1672
01:13:31,494 --> 01:13:32,535
నేను ఆ డేటా మార్పు ఉండవచ్చు.

1673
01:13:32,535 --> 01:13:35,030
నేను వ్రాసే వెళ్ళవచ్చు
డాటాబేస్ డేటా తిరిగి.

1674
01:13:35,030 --> 01:13:38,100
ఎవరైనా రికార్డు మారితే,
స్టాంప్ మార్చబడింది ఉండవచ్చు.

1675
01:13:38,100 --> 01:13:40,370
ఆ విధంగా నా నియత
నవీకరణ నవీకరణ చెప్పగల్గినవి

1676
01:13:40,370 --> 01:13:42,340
స్టాంప్ ఈ సమానం ఉంటే.

1677
01:13:42,340 --> 01:13:46,290
లేదా నవీకరణ ఎవరైనా ఎందుకంటే విఫలమౌతుంది
ఈ మధ్యకాలంలో రికార్డు నవీకరించబడింది.

1678
01:13:46,290 --> 01:13:48,290
>> మేము ఆశావాద లాకింగ్ కాల్ ఏమిటి.

1679
01:13:48,290 --> 01:13:50,670
ఇది ఎవరైనా అర్థం
లో వచ్చి అది మార్చవచ్చు,

1680
01:13:50,670 --> 01:13:53,100
మరియు నేను దానిని కనిపెట్టే వెళుతున్న
నేను తిరిగి వెళ్ళేటప్పుడు రాయడానికి.

1681
01:13:53,100 --> 01:13:56,106
ఆపై నేను నిజానికి ఆ చదువుకోవచ్చు
డేటా మరియు OH, అతను మార్చివేసి, చెప్పటానికి.

1682
01:13:56,106 --> 01:13:57,230
నేను ఆ కోసం ఖాతా అవసరం.

1683
01:13:57,230 --> 01:14:00,490
మరియు నేను డేటా మార్చవచ్చు నా
రికార్డు మరియు మరొక నవీకరణ వర్తిస్తాయి.

1684
01:14:00,490 --> 01:14:04,330
కాబట్టి మీరు ఆ పెరుగుతున్న చేసుకోవచ్చు
సమయం మధ్య సంభవించే నవీకరణలను

1685
01:14:04,330 --> 01:14:08,740
మీరు డేటా మరియు చదివే
సమయం మీరు డేటా వ్రాస్తానని.

1686
01:14:08,740 --> 01:14:11,520
>> ప్రేక్షకులు: వడపోత
వ్యక్తీకరణ నిజానికి కాదు అర్థం

1687
01:14:11,520 --> 01:14:13,020
సంఖ్య లేదా not-- లో

1688
01:14:13,020 --> 01:14:14,316
>> [వాయిసెస్ INTERPOSING]

1689
01:14:14,316 --> 01:14:16,232
రిక్ HOULIHAN: నేను రెడీ
ఈ లోకి చాలా పొందండి.

1690
01:14:16,232 --> 01:14:17,700
ఈ రిజర్వేషన్ కీవర్డ్ ఉంది.

1691
01:14:17,700 --> 01:14:20,130
పౌండ్ వీక్షణ ప్రత్యేకించబడింది
డైనమో DB లో కీవర్డ్.

1692
01:14:20,130 --> 01:14:24,500
ప్రతి డేటాబేస్ ఉంది దాని సొంత రిజర్వు
మీరు ఉపయోగించలేరు సేకరణలు పేర్లు.

1693
01:14:24,500 --> 01:14:27,240
డైనమో DB, మీరు తెలిపితే
ఈ ముందు ఒక పౌండ్,

1694
01:14:27,240 --> 01:14:29,310
మీరు పైన ఆ పేర్లు అప్ నిర్వచించలేదు.

1695
01:14:29,310 --> 01:14:31,840
ఈ ఒక సూచించబడిన విలువ.

1696
01:14:31,840 --> 01:14:34,880
ఇది బహుశా ఉత్తమ వాక్యనిర్మాణం కాదు
ఈ చర్చకు అక్కడ,

1697
01:14:34,880 --> 01:14:38,090
అది కొన్ని real-- భరోసా ఎందుకంటే
నేను మాట్లాడటం ఉండేది మరింత

1698
01:14:38,090 --> 01:14:41,360
ఒక లోతుగా స్థాయిలో ఆ గురించి.

1699
01:14:41,360 --> 01:14:46,130
>> కానీ చెప్పటానికి తగినంత, ఈ అనుకొనుట
వారు views-- పేరు స్కాన్ ప్రశ్న అనేది

1700
01:14:46,130 --> 01:14:50,190
లేదా పౌండ్ వీక్షణలు 10 కంటే ఎక్కువ.

1701
01:14:50,190 --> 01:14:54,660
ఇది అవును, ఒక సంఖ్యా విలువ.

1702
01:14:54,660 --> 01:14:57,322
మీకు కావాలంటే, మేము గురించి మాట్లాడవచ్చు
చర్చ తర్వాత ఆ.

1703
01:14:57,322 --> 01:15:00,030
All right, కాబట్టి మేము లోకి పొందుతుంటే
ఉత్తమ విధానాల కొన్ని దృశ్యాలు

1704
01:15:00,030 --> 01:15:02,000
పేరు మేము మాట్లాడటానికి వెళుతున్న
ఇక్కడ కొన్ని అనువర్తనాలు గురించి.

1705
01:15:02,000 --> 01:15:03,810
డైనమో DB కొరకు వినియోగ సందర్భాలు ఏమిటి.

1706
01:15:03,810 --> 01:15:06,120
డిజైన్ ఏమిటి
డైనమో DB లో నమూనాల.

1707
01:15:06,120 --> 01:15:09,110
>> మరియు మొదటి ఒకటి మేము చేయబోతున్నామని
గురించి చర్చ విషయాలు ఇంటర్నెట్ ఉంది.

1708
01:15:09,110 --> 01:15:15,010
నేను ఊహిస్తున్నాను of-- కాబట్టి మేము చాలా పొందుటకు,
దానిని 50% పైగా ఏమిటి

1709
01:15:15,010 --> 01:15:19,370
ఈ రోజుల్లో ఇంటర్నెట్ ట్రాఫిక్
నిజానికి యంత్రాలు ద్వారా ఉత్పత్తి,

1710
01:15:19,370 --> 01:15:21,930
లేదు మానవులు స్వయంచాలక ప్రక్రియలు.

1711
01:15:21,930 --> 01:15:25,140
నేను ఈ విషయం ఈ విషయం అర్థం
మీరు మీ జేబులో చుట్టూ తీసుకుని

1712
01:15:25,140 --> 01:15:28,840
ఎంత డేటా ఆ విషయం
నిజానికి మీరు లేకుండా చుట్టూ పంపడం

1713
01:15:28,840 --> 01:15:30,550
అది తెలుసుకోవడం ఖచ్చితంగా అద్భుతమైన ఉంది.

1714
01:15:30,550 --> 01:15:34,970
మీ స్థానం సమాచారం
ఎంత వేగంగా గురించి మీరు చూడాలని.

1715
01:15:34,970 --> 01:15:38,400
మీరు Google Maps రచనలు ఎలా అనుకుంటున్నారు
వారు మీరు చెప్పినపుడు ట్రాఫిక్ ఏమిటి.

1716
01:15:38,400 --> 01:15:41,275
లక్షలాది ఉన్నాయి ఎందుకంటే అది మరియు
చుట్టూ డ్రైవింగ్ లక్షల మంది ప్రజలు

1717
01:15:41,275 --> 01:15:44,667
పంపుతున్నారు ఫోన్లతో
అన్ని సమయంలో చోట్ల డేటా.

1718
01:15:44,667 --> 01:15:46,500
విషయాలు ఒకటి కాబట్టి
డేటా ఈ రకం గురించి

1719
01:15:46,500 --> 01:15:50,980
ఆ వస్తుంది, మానిటర్ డేటా లాగిన్
డేటా సమయ శ్రేణి డేటా, అది ఉంది

1720
01:15:50,980 --> 01:15:53,540
సాధారణంగా మాత్రమే ఆసక్తికరమైన
సమయం కొద్దిగా కోసం.

1721
01:15:53,540 --> 01:15:55,580
ఆ సమయంలో తర్వాత, అంతే
కాబట్టి ఆసక్తికరమైన లేదు.

1722
01:15:55,580 --> 01:15:58,390
కాబట్టి మేము వీలు లేదు గురించి మాట్లాడారు
ఆ పట్టికలు హద్దులు లేకుండా పెరుగుతాయి.

1723
01:15:58,390 --> 01:16:03,410
ఇక్కడ ఆలోచన బహుశా నేను 24 పొందారు
నా వేడి బల్ల ఈవెంట్స్ విలువ గంటల.

1724
01:16:03,410 --> 01:16:06,160
మరియు ఆ వేడి బల్ల అవతరిస్తుంది
చాలా అధిక రేటు వెసులుబాటు,

1725
01:16:06,160 --> 01:16:07,950
ఇది దత్తాంశం యొక్క పలు తీసుకొని ఎందుకంటే.

1726
01:16:07,950 --> 01:16:10,920
ఇది డేటా చాలా సమయం పడుతోంది
మరియు నేను చాలా వింటున్నాను.

1727
01:16:10,920 --> 01:16:14,560
నేను ఆపరేషన్ చాలా పొందారు
ఆ డేటా వ్యతిరేకంగా నడుస్తున్న ప్రశ్నలు.

1728
01:16:14,560 --> 01:16:18,120
>> 24 గంటల తర్వాత హే, మీరు
నేను పట్టించుకోను ఏమి, తెలుసు.

1729
01:16:18,120 --> 01:16:21,150
కాబట్టి బహుశా ప్రతి అర్ధరాత్రి నేను రోల్
ఒక కొత్త పట్టిక కు పైగా నా పట్టిక

1730
01:16:21,150 --> 01:16:22,430
మరియు నేను ఈ పట్టిక deprovision.

1731
01:16:22,430 --> 01:16:26,440
నేను తీసుకొని వెళ్తాము RCU మరియు
WCU యొక్క డౌన్ ఎందుకంటే 24 గంటల తరువాత

1732
01:16:26,440 --> 01:16:28,630
నేను అనేక నడుస్తున్న కాదు
ఆ డేటా వ్యతిరేకంగా ప్రశ్నలు.

1733
01:16:28,630 --> 01:16:30,200
ఐతే నేను డబ్బు సేవ్ వెళుతున్న.

1734
01:16:30,200 --> 01:16:32,940
మరియు బహుశా 30 రోజుల తరువాత నాదగ్గర
కూడా అది అన్ని పట్టించుకోనట్లు అవసరం.

1735
01:16:32,940 --> 01:16:35,020
నేను WCU యొక్క పడుతుంది
ఒకటి క్రిందికి అన్ని మార్గం,

1736
01:16:35,020 --> 01:16:36,990
మీరు తెలుసు ఎందుకంటే, అది ఏమిటి
ఎప్పుడూ రాసిన పొందగలిగిన.

1737
01:16:36,990 --> 01:16:38,300
డేటా 30 రోజుల వయస్సు.

1738
01:16:38,300 --> 01:16:40,000
ఇది ఎప్పుడూ మార్పులు.

1739
01:16:40,000 --> 01:16:44,200
>> మరియు అది చదవడానికి పొందగలిగిన దాదాపు ఎప్పటికీ
కాబట్టి యొక్క కేవలం 10 క్రిందికి ఆ RCU తీసుకుందాం.

1740
01:16:44,200 --> 01:16:49,372
మరియు నేను ఈ డబ్బు, ఒక టన్ను సేవ్ కాబట్టి
డేటా, మరియు మాత్రమే నా వేడి డేటా చెల్లిస్తున్న.

1741
01:16:49,372 --> 01:16:52,330
కాబట్టి ఆ చూడండి ముఖ్యమైన విషయం
మీరు ఒక సమయ శ్రేణి చూస్తున్నప్పుడు వద్ద

1742
01:16:52,330 --> 01:16:54,716
డేటా వాల్యూమ్ లో వస్తున్న.

1743
01:16:54,716 --> 01:16:55,590
ఈ వ్యూహాలు ఉన్నాయి.

1744
01:16:55,590 --> 01:16:58,010
ఇప్పుడు, నేను అది వీలు కాలేదు
ఒకే పట్టిక వెళ్లి

1745
01:16:58,010 --> 01:16:59,461
మరియు కేవలం పట్టిక పెరుగుతాయి తెలపండి.

1746
01:16:59,461 --> 01:17:01,460
చివరికి, నేను వెళుతున్న
పనితీరు సమస్యలను చూడండి.

1747
01:17:01,460 --> 01:17:04,060
నేను ఆర్కైవ్ ప్రారంభించడానికి కలిగి వెళుతున్న
పట్టిక ఆఫ్ డేటా కొన్ని,

1748
01:17:04,060 --> 01:17:04,720
ఏమి లేదు.

1749
01:17:04,720 --> 01:17:07,010
>> యొక్క మెరుగైన లెట్
మీ అనువర్తన రూపకల్పన

1750
01:17:07,010 --> 01:17:08,900
కాబట్టి మీరు కుడి ఈ విధంగా పనిచేస్తుంటాయి.

1751
01:17:08,900 --> 01:17:11,460
కనుక ఇది కేవలం స్వయంచాలకం
అప్లికేషన్ కోడ్ లో.

1752
01:17:11,460 --> 01:17:13,580
అర్ధరాత్రి ప్రతి రాత్రి
ఇది పట్టిక ఉంచబడతాయి.

1753
01:17:13,580 --> 01:17:17,170
బహుశా నేను అవసరం ఒక స్లయిడింగ్ ఉంది
డేటా 24 గంటల విండో.

1754
01:17:17,170 --> 01:17:20,277
అప్పుడు రోజూ నేను ఉన్నాను
పట్టిక ఆఫ్ డేటా పిలుపునిచ్చింది.

1755
01:17:20,277 --> 01:17:22,360
నేను ఒక దాన్ని ట్రిమ్ చేస్తున్నాను
క్రాన్ ఉద్యోగం మరియు నేను ఆటంకమవుతుంది

1756
01:17:22,360 --> 01:17:24,160
ఈ ఇతర పట్టికలు పై,
మీరు అవసరం సంసార.

1757
01:17:24,160 --> 01:17:25,940
ఒక చెల్లింపులో పనిచేస్తుంది కాబట్టి, ఆ గొప్ప.

1758
01:17:25,940 --> 01:17:27,080
లేకపోతే, అది ట్రిమ్.

1759
01:17:27,080 --> 01:17:29,640
కానీ యొక్క ఆ వేడి డేటా భద్రము
దూరంగా మీ చల్లని డేటా నుండి.

1760
01:17:29,640 --> 01:17:32,535
ఇది మీరు డబ్బు సేవ్ చేస్తాము మరియు
మీ పట్టికలు మరింత ప్రదర్శన చేయడానికి.

1761
01:17:32,535 --> 01:17:35,960

1762
01:17:35,960 --> 01:17:38,210
సో తదుపరి విషయం మేము మాట్లాడదాము
గురించి ఉత్పత్తి జాబితా ఉంది.

1763
01:17:38,210 --> 01:17:42,000
ఉత్పత్తి కేటలాగ్
అందంగా సాధారణ ఉపయోగం కేసు.

1764
01:17:42,000 --> 01:17:46,600
ఈ నిజానికి ఒక సాధారణ నమూనా
మేము విషయాలు వివిధ చూస్తారు.

1765
01:17:46,600 --> 01:17:48,870
మీరు కోసం, ట్విట్టర్ తెలుసు
ఉదాహరణకు, వేడి ట్వీట్.

1766
01:17:48,870 --> 01:17:51,280
అందరూ వస్తున్నాయో మరియు
ఆ ట్వీట్ నేర్పవచ్చు.

1767
01:17:51,280 --> 01:17:52,680
ఉత్పత్తి జాబితా, నేను ఒక అమ్మకానికి వచ్చింది.

1768
01:17:52,680 --> 01:17:54,120
నేను ఒక వేడి అమ్మకానికి వచ్చింది.

1769
01:17:54,120 --> 01:17:57,277
నేను 70,000 అభ్యర్థనలు వచ్చింది
రెండవ ఒక ఉత్పత్తి కోసం వచ్చే

1770
01:17:57,277 --> 01:17:58,860
నా ఉత్పత్తి జాబితా బయటకు వివరణ.

1771
01:17:58,860 --> 01:18:02,384
మేము రిటైల్ చూడవచ్చని
ఆపరేషన్ కొంచెం.

1772
01:18:02,384 --> 01:18:03,550
సో ఎలా మేము ఆ మర్చిపోయావా?

1773
01:18:03,550 --> 01:18:04,924
ఆ పరిష్కరించేందుకు మార్గమే లేదు.

1774
01:18:04,924 --> 01:18:07,110
నా వినియోగదారులు చూడాలనుకుంటే
డేటా అదే ముక్క.

1775
01:18:07,110 --> 01:18:09,410
వారు పాటే, వస్తున్నాయి చేస్తున్నారు.

1776
01:18:09,410 --> 01:18:11,920
మరియు వారు అన్ని అభ్యర్థనలను చేస్తున్న
డేటా అదే ముక్క కోసం.

1777
01:18:11,920 --> 01:18:16,240
ఈ నాకు ఇచ్చే వేడి కీ, ఆ పెద్ద ఎర్ర
మేము ఇష్టం లేని నా చార్టులో గీత.

1778
01:18:16,240 --> 01:18:17,720
మరియు ఆ కనిపిస్తోంది ఏమిటి.

1779
01:18:17,720 --> 01:18:22,290
నా కీ స్పేస్ అంతటా నేను పొందుతున్నాను కాబట్టి
అమ్మకానికి అంశాలు సుత్తితోకొట్టి.

1780
01:18:22,290 --> 01:18:24,070
నేను ఎక్కడైనా ఏమీ పొందుతున్నాను.

1781
01:18:24,070 --> 01:18:26,050
>> నేను ఈ సమస్యను పరిష్కరించేందుకు చెయ్యాలి?

1782
01:18:26,050 --> 01:18:28,410
Well, మేము కాష్ తో దీని తీవ్రతను.

1783
01:18:28,410 --> 01:18:33,630
Cache, మీరు-మెమరీ ప్రాథమికంగా ఒక చాలు
డేటాబేస్ ముందు విభజన.

1784
01:18:33,630 --> 01:18:37,260
మేము ఉండిపోయారు
[వినబడని] కాష్, ఎలా మీరు

1785
01:18:37,260 --> 01:18:40,260
మీ స్వంత కాష్ అప్ సెట్ చేయవచ్చు, [వినబడని]
కాష్ [? d,?] మీకు కావలసిన సంసార.

1786
01:18:40,260 --> 01:18:42,220
డేటాబేస్ ముందు ఆ కనబరచింది.

1787
01:18:42,220 --> 01:18:47,250
ఆ విధంగా మీరు ఆ డేటా నిల్వ చేయవచ్చు
కాష్ లో ఆ వేడి కీలు నుండి

1788
01:18:47,250 --> 01:18:49,390
స్పేస్ మరియు కాష్ ద్వారా చదవండి.

1789
01:18:49,390 --> 01:18:51,962
>> మరియు అప్పుడు చాలా మీ చదువుతుంది
ఈ మాదిరి మొదలు.

1790
01:18:51,962 --> 01:18:54,920
నేను ఈ కాష్ ఇక్కడ అన్ని అప్ హిట్ గాట్
మరియు నేను ఏమీ డౌన్ ఇక్కడ జరగబోతోంది కాకముందు

1791
01:18:54,920 --> 01:18:59,330
డేటాబేస్ వెనుక కూర్చొని ఎందుకంటే
కాష్ మరియు ద్వారా వచ్చి ఎప్పుడూ చదువుతుంది.

1792
01:18:59,330 --> 01:19:02,520
నేను డేటా మారిస్తే
డేటాబేస్, నేను కాష్ అప్డేట్ ఉంటుంది.

1793
01:19:02,520 --> 01:19:04,360
మేము ఏదో ఉపయోగించవచ్చు
వంటి అలా steams.

1794
01:19:04,360 --> 01:19:07,360
నేను ఆ పని ఎలా వివరించడానికి చేస్తాము.

1795
01:19:07,360 --> 01:19:09,060
అన్ని కుడి, సందేశ.

1796
01:19:09,060 --> 01:19:11,180
ఇమెయిల్, మేము అన్ని ఇమెయిల్ ఉపయోగించండి.

1797
01:19:11,180 --> 01:19:12,540
>> ఈ ఒక అందమైన మంచి ఉదాహరణ.

1798
01:19:12,540 --> 01:19:14,950
మేము సందేశాలను పట్టిక విధమైన పొందారు.

1799
01:19:14,950 --> 01:19:17,040
మరియు మేము ఇన్బాక్స్ మరియు అవుట్బాక్స్ వచ్చింది.

1800
01:19:17,040 --> 01:19:19,760
ఈ ఏమి SQL చేస్తాను ఉంది
ఆ ఇన్బాక్స్ నిర్మించడానికి ఎలా.

1801
01:19:19,760 --> 01:19:23,350
మేము రకమైన రకమైన ఉపయోగించడానికి
GSI యొక్క GSI యొక్క, ఉపయోగించడానికి వ్యూహం

1802
01:19:23,350 --> 01:19:25,320
నా ఇన్బాక్స్ మరియు నా అవుట్బాక్స్ కోసం.

1803
01:19:25,320 --> 01:19:27,600
కాబట్టి నేను ముడి సందేశాలను వస్తోంది పొందారు
నా సందేశాలు పట్టిక లోకి.

1804
01:19:27,600 --> 01:19:30,194
మరియు ఈ మొదటి విధానం
కావచ్చు, సరే, ఏ సమస్య, చెప్పటానికి.

1805
01:19:30,194 --> 01:19:31,110
నేను ముడి సందేశాలను పొందారు.

1806
01:19:31,110 --> 01:19:33,710
వచ్చే సందేశాలు [వినబడని]
సందేశం ID, ఆ గొప్ప.

1807
01:19:33,710 --> 01:19:35,070
ఆ నా ఏకైక హాష్ వార్తలు.

1808
01:19:35,070 --> 01:19:38,280
నేను రెండు GSI యొక్క సృష్టించడానికి ఒక వెళుతున్న
నా ఇన్బాక్స్, నా అవుట్బాక్స్ కోసం ఒక కోసం.

1809
01:19:38,280 --> 01:19:40,530
మరియు మొదటి విషయం నేను చేస్తాను
నేను నా హాష్ కీ అని వస్తుంది ఉంది

1810
01:19:40,530 --> 01:19:43,310
గ్రహీత అవతరిస్తుంది మరియు
నేను తేదీ ఏర్పాట్లు వెళుతున్న.

1811
01:19:43,310 --> 01:19:44,220
ఈ అద్భుతమైన ఉంది.

1812
01:19:44,220 --> 01:19:45,890
నేను ఇక్కడ నా nice view వచ్చింది.

1813
01:19:45,890 --> 01:19:47,780
కానీ ఒక చిన్న సమస్య ఇక్కడే ఉంది.

1814
01:19:47,780 --> 01:19:50,891
మరియు మీరు ఈ లోకి అమలు
రిలేషనల్ డేటాబేస్ అలాగే.

1815
01:19:50,891 --> 01:19:52,390
వారు నిలువుగా విభజనీకరణ అని.

1816
01:19:52,390 --> 01:19:55,840
మీరు మీ బిగ్ డేటా ఉంచాలని
దూరంగా మీ చిన్న డేటా నుండి.

1817
01:19:55,840 --> 01:20:00,470
>> నేను gotta ఎందుకంటే కారణం ఉంది
గుణాలు పొందడానికి అంశాలను చదివి వెళ్ళి.

1818
01:20:00,470 --> 01:20:05,570
మరియు నా శరీరాలు ఇక్కడ అన్ని ఉన్నాయి ఉంటే,
అప్పుడు కేవలం కొన్ని అంశాలను చదవడం

1819
01:20:05,570 --> 01:20:08,560
నా శరీరం పొడవు ఉంటే
256 కిలోబైట్లు ప్రతి సగటున

1820
01:20:08,560 --> 01:20:10,991
గణిత అందంగా అగ్లీ పొందుతాడు.

1821
01:20:10,991 --> 01:20:12,490
కాబట్టి నేను డేవిడ్ యొక్క ఇన్బాక్స్కు చదవండి అనుకుందాం.

1822
01:20:12,490 --> 01:20:14,520
డేవిడ్ యొక్క ఇన్బాక్స్కు 50 అంశాలు ఉన్నాయి.

1823
01:20:14,520 --> 01:20:17,880
సగటు మరియు పరిమాణం 256 కిలోబైట్లు ఉంది.

1824
01:20:17,880 --> 01:20:21,730
ఇక్కడ నా మార్పిడి నిష్పత్తి వార్తలు
RCU యొక్క నాలుగు కిలోబైట్లు ఉంది.

1825
01:20:21,730 --> 01:20:24,450
>> OK, యొక్క వీడలేదు
చివరికి స్థిరమైన చదువుతుంది.

1826
01:20:24,450 --> 01:20:28,640
నేను ఇప్పటికీ 1600 RCU యొక్క తినడం ఉన్నాను
డేవిడ్ యొక్క ఇన్బాక్స్కు చదవడానికి.

1827
01:20:28,640 --> 01:20:29,950
ఔచ్.

1828
01:20:29,950 --> 01:20:31,980
సరే, ఇప్పుడు అనుకుంటున్నాను తెలియజేయండి
అనువర్తనం ఎలా పనిచేస్తుందో గురించి.

1829
01:20:31,980 --> 01:20:35,340
నేను ఒక ఇమెయిల్ అనువర్తనం ఉన్నాను ఉంటే మరియు
నేను, నా ఇన్బాక్స్ వద్ద చూస్తున్నాను

1830
01:20:35,340 --> 01:20:39,680
మరియు నేను ప్రతి సందేశం యొక్క శరీరం చూడండి,
లేదు, నేను సారాంశాలు చూస్తున్నాను.

1831
01:20:39,680 --> 01:20:41,850
నేను మాత్రమే శీర్షికలు వద్ద చూస్తున్నాను.

1832
01:20:41,850 --> 01:20:46,310
కాబట్టి యొక్క ఒక టేబుల్ స్ట్రక్చర్ నిర్మించడానికి వీలు
మరింత ఆ కనిపిస్తుంది.

1833
01:20:46,310 --> 01:20:49,470
>> కాబట్టి ఇక్కడ సమాచారాన్ని వార్తలు
నా వర్క్ఫ్లో అవసరం.

1834
01:20:49,470 --> 01:20:50,890
ఇది నా ఇన్బాక్స్ GSI ఉంది.

1835
01:20:50,890 --> 01:20:53,800
ఇది తేదీ వార్తలు, పంపినవారు,
విషయం, మరియు అప్పుడు

1836
01:20:53,800 --> 01:20:56,790
చూపాడు ఇది సందేశాన్ని ID,
తిరిగి సందేశాలను పట్టిక

1837
01:20:56,790 --> 01:20:57,850
నేను ఎక్కడ శరీరం పొందవచ్చు.

1838
01:20:57,850 --> 01:21:01,260

1839
01:21:01,260 --> 01:21:04,420
Well, ఈ రికార్డు ఐడిలను ఉంటుంది.

1840
01:21:04,420 --> 01:21:09,850
వారు తిరిగి పాయింటు ఉంటుంది
డైనమో DB పట్టిక అంశం ID లు.

1841
01:21:09,850 --> 01:21:12,220
ప్రతి సూచిక ఎల్లప్పుడూ సృష్టిస్తుంది
ఎప్పుడూ అంశం ఉంది

1842
01:21:12,220 --> 01:21:15,750
ఆ of-- భాగంగా ID
సూచిక వస్తుంది.

1843
01:21:15,750 --> 01:21:17,414
>> అయితే సరే.

1844
01:21:17,414 --> 01:21:19,080
ప్రేక్షకులు: ఇది చెబుతుంది ఇది నిల్వ చోట?

1845
01:21:19,080 --> 01:21:21,420
రిక్ HOULIHAN: అవును, అది చెబుతుంది
exactly-- అది సరిగ్గా ఏమిటి.

1846
01:21:21,420 --> 01:21:22,644
అది ఇక్కడ చెప్పారు నా తిరిగి రికార్డు.

1847
01:21:22,644 --> 01:21:24,310
మరియు అది నా తిరిగి రికార్డు దానిని తిరిగి అభిప్రాయపడుతున్నారు చేస్తాము.

1848
01:21:24,310 --> 01:21:26,460
సరిగ్గా.

1849
01:21:26,460 --> 01:21:29,490
OK, కాబట్టి ఇప్పుడు నా ఇన్బాక్స్ ఉంది
నిజానికి చాలా చిన్న.

1850
01:21:29,490 --> 01:21:32,210
మరియు ఈ నిజంగా మద్దతు
ఒక ఇమెయిల్ అనువర్తనం వర్క్ఫ్లో.

1851
01:21:32,210 --> 01:21:34,230
నా ఇన్బాక్స్ కాబట్టి, నేను క్లిక్.

1852
01:21:34,230 --> 01:21:38,160
నేను వెంట వెళ్ళి నేను సందేశాన్ని క్లిక్,
నేను శరీరం పొందడానికి వెళ్ళడానికి అవసరమైనప్పుడు ఆ,

1853
01:21:38,160 --> 01:21:40,180
నేను వెళుతున్న ఎందుకంటే
వేరొక అభిప్రాయం వెళ్ళండి.

1854
01:21:40,180 --> 01:21:43,870
మీరు MVC రకం గురించి ఆలోచించడం చేస్తే
ఫ్రేమ్, మోడల్ వీక్షణ నియంత్రిక.

1855
01:21:43,870 --> 01:21:46,120
>> మోడల్ కలిగి
డేటా వీక్షణ అవసరాలను ఆ

1856
01:21:46,120 --> 01:21:48,130
మరియు నియంత్రిక సంకర్షణ.

1857
01:21:48,130 --> 01:21:51,670
నేను ఫ్రేమ్ మారినప్పుడు, ఎప్పుడు
నేను కోణం మార్చడానికి,

1858
01:21:51,670 --> 01:21:55,080
అది తిరిగి వెళ్ళడానికి సరే
సర్వర్ మరియు మోడల్ సంతానోత్పత్తి జరిపించేందుకు,

1859
01:21:55,080 --> 01:21:56,860
ఆ యూజర్ ఆశిస్తున్నట్లు ఏమి ఎందుకంటే.

1860
01:21:56,860 --> 01:22:00,530
వారు వీక్షణలు మారినప్పుడు, ఆ ఉన్నప్పుడు
మేము తిరిగి డేటాబేస్ వెళ్ళవచ్చు.

1861
01:22:00,530 --> 01:22:02,480
కాబట్టి ఇమెయిల్, క్లిక్ చేయండి.

1862
01:22:02,480 --> 01:22:03,710
నేను శరీరం కోసం చూస్తున్నాను.

1863
01:22:03,710 --> 01:22:04,330
రౌండ్ ట్రిప్.

1864
01:22:04,330 --> 01:22:05,680
శరీరం పొందుటకు వెళ్ళండి.

1865
01:22:05,680 --> 01:22:06,950
>> నేను చాలా తక్కువ డేటా చదవండి.

1866
01:22:06,950 --> 01:22:09,960
నేను మాత్రమే శరీరాలు వింటున్నాను ఆ
అతను వాటిని అవసరం ఉన్నప్పుడు డేవిడ్ కావాలి.

1867
01:22:09,960 --> 01:22:14,230
నేను 1600 లో బర్న్ కాదు
RCU యొక్క కేవలం తన ఇన్బాక్స్ చూపించడానికి.

1868
01:22:14,230 --> 01:22:17,670
కాబట్టి ఇప్పుడు ఈ మార్గం ఆ
LSI లేదా GSI-- నేను క్షమించండి,

1869
01:22:17,670 --> 01:22:19,900
GSI, అవుతుంది.

1870
01:22:19,900 --> 01:22:25,450
మేము గ్రహీత మీద మా హాష్ పొందారు.

1871
01:22:25,450 --> 01:22:27,030
మేము తేదీ పరిధి కీ పొందారు.

1872
01:22:27,030 --> 01:22:31,380
మరియు మేము అంచనా గుణాలు పొందారు
మేము వీక్షణ మద్దతు మాత్రమే అవసరమైన.

1873
01:22:31,380 --> 01:22:34,300
>> మేము అవుట్బాక్స్ ఆ రొటేట్.

1874
01:22:34,300 --> 01:22:35,770
పంపినవారు హాష్.

1875
01:22:35,770 --> 01:22:39,612
మరియు ఆ, సారాన్ని, మేము కలిగి
మంచిపని, శుభ్రంగా వీక్షణ.

1876
01:22:39,612 --> 01:22:41,570
మరియు అది ప్రధానంగా మేము వార్తలు
ఈ nice సందేశాలు కలిగి

1877
01:22:41,570 --> 01:22:45,870
చక్కగా ఎందుకంటే వ్యాప్తి చేయబడిన ఆ పట్టిక
ఇది హాష్ మాత్రమే, హ్యాష్ సందేశం ID వార్తలు.

1878
01:22:45,870 --> 01:22:51,750
మరియు మేము రెండు సూచికలు కలిగి
పట్టిక ఆఫ్ భ్రమణ ఉంటాయి.

1879
01:22:51,750 --> 01:22:57,411
All right, కాబట్టి ఇక్కడ ఆలోచన చేయాలని కాదు
పెద్ద డేటా మరియు ఈ చిన్న డేటా ఉంచడానికి

1880
01:22:57,411 --> 01:22:57,910
కలిసి.

1881
01:22:57,910 --> 01:23:00,700
నిలువుగా విభజన
ఆ పట్టికలు విభజన.

1882
01:23:00,700 --> 01:23:03,150
డేటా చదవడానికి లేదు మీకు లేదు.

1883
01:23:03,150 --> 01:23:04,850
అన్ని కుడి, గేమింగ్.

1884
01:23:04,850 --> 01:23:06,990
మేము అన్ని గేమ్స్ ఇష్టం.

1885
01:23:06,990 --> 01:23:10,902
కనీసం నేను అప్పుడు గేమ్స్ ఇష్టం.

1886
01:23:10,902 --> 01:23:12,735
కొన్ని విషయాలను కాబట్టి
మేము ఉన్నప్పుడు వ్యవహరించే

1887
01:23:12,735 --> 01:23:14,193
మేము కుడి, గేమింగ్ గురించి ఆలోచిస్తూ?

1888
01:23:14,193 --> 01:23:16,999
ఈ రోజుల్లో గేమింగ్, ముఖ్యంగా మొబైల్
గేమింగ్, అన్ని ఆలోచన గురించి.

1889
01:23:16,999 --> 01:23:19,540
నేను ఇక్కడ ఒక రొటేట్ వెళుతున్న
దూరంగా DynamoDB నుండి కొద్దిగా.

1890
01:23:19,540 --> 01:23:21,373
నేను తీసుకుని వెళుతున్న
చర్చ కొన్ని

1891
01:23:21,373 --> 01:23:24,240
కొన్ని చుట్టూ
ఇతర AWS సాంకేతికతలు.

1892
01:23:24,240 --> 01:23:28,930
>> కానీ గేమింగ్ గురించి ఆలోచన ఆలోచించడం ఉంది
API లు పరంగా గురించి, అని API లు,

1893
01:23:28,930 --> 01:23:31,730
సాధారణంగా, HTTP మరియు JSON మాట్లాడుతూ.

1894
01:23:31,730 --> 01:23:34,550
ఇది ఎలా మొబైల్ గేమ్స్ రకమైన
వారి వెనుక చివరలను సంకర్షణ.

1895
01:23:34,550 --> 01:23:35,850
వారు JSON పోస్ట్ చేయండి.

1896
01:23:35,850 --> 01:23:40,660
వారు డేటా పొందుటకు, మరియు అది అంతే,
సాధారణంగా nice JSON API లు, మాట్లాడే.

1897
01:23:40,660 --> 01:23:44,950
>> స్నేహితులు పొందడానికి వంటి విషయాలు, పొందండి
లీడర్బోర్డ్, మార్పిడి డేటా

1898
01:23:44,950 --> 01:23:47,699
వినియోగదారు రూపొందించిన కంటెంట్ను,
వ్యవస్థ వరకు తిరిగి పుష్,

1899
01:23:47,699 --> 01:23:49,740
ఈ విషయాలు రకాలు
మేము చేయబోతున్నామని ఆ.

1900
01:23:49,740 --> 01:23:52,542
బైనరీ ఆస్తి డేటా, ఈ డేటాను
డేటాబేస్ లో కూర్చుని లేదు.

1901
01:23:52,542 --> 01:23:54,250
ఈ ఒక లో కూర్చుని ఉండవచ్చు
వస్తువు స్టోర్, కుడి?

1902
01:23:54,250 --> 01:23:56,541
కానీ డేటాబేస్ అన్నారు
సిస్టమ్ చెప్పుచున్నారు ముగుస్తుంది,

1903
01:23:56,541 --> 01:23:59,140
అప్లికేషన్ చెప్పడం
అక్కడ అది పొందడానికి వెళ్ళడానికి.

1904
01:23:59,140 --> 01:24:03,550
అనివార్యంగా, మల్టీప్లేయర్
సర్వర్లు, తిరిగి ముగింపు అవస్థాపన,

1905
01:24:03,550 --> 01:24:06,180
మరియు అధిక కోసం రూపొందించిన
లభ్యత మరియు వ్యాప్తిని.

1906
01:24:06,180 --> 01:24:09,400
కాబట్టి ఈ మేము అన్ని కావలసిన వస్తువులు ఉన్నాయి
గేమింగ్ మౌలిక నేడు.

1907
01:24:09,400 --> 01:24:12,160
>> కాబట్టి యొక్క పరిశీలించి తెలియజేయండి
ఏమి ఆ కనిపిస్తుంది.

1908
01:24:12,160 --> 01:24:16,070
కోర్ తిరిగి ముగింపు వచ్చింది
చాలా సూటిగా.

1909
01:24:16,070 --> 01:24:19,880
మేము ఇక్కడ ఒక వ్యవస్థ వచ్చింది
బహుళ లభ్యత మండలాలు.

1910
01:24:19,880 --> 01:24:23,780
అనుకుంటున్నాను being-- మేము AZs గురించి మాట్లాడారు
వాటిని ప్రత్యేక డేటా కేంద్రాలుగా.

1911
01:24:23,780 --> 01:24:26,040
ఒకటి కంటే ఎక్కువ డేటా సెంటర్
AZ శాతం, కానీ ఆ సరే

1912
01:24:26,040 --> 01:24:28,831
కేవలం ప్రత్యేక డేటా వంటి వాటిని భావిస్తారు
భౌగోళికంగా అని కేంద్రాలు

1913
01:24:28,831 --> 01:24:30,090
మరియు తప్పు ఒంటరిగా.

1914
01:24:30,090 --> 01:24:32,172
>> మేము ఒక చూడాలని
జంట ఇసి 2 చోట్ల.

1915
01:24:32,172 --> 01:24:33,880
మేము చూడాలని
కొన్ని తిరిగి ముగింపు సర్వర్.

1916
01:24:33,880 --> 01:24:35,800
మీరు వారసత్వంగా ఉన్నాము బహుశా ఉంటే
నిర్మాణం, మేము ఉన్నాము

1917
01:24:35,800 --> 01:24:38,920
మేము RDS కాల్ ఏమి ఉపయోగించి,
రిలేషనల్ డేటాబేస్ సేవలు.

1918
01:24:38,920 --> 01:24:42,040
MSSQL, MySQL కావచ్చు,
లేదా అలాంటిదే.

1919
01:24:42,040 --> 01:24:47,080
ఈ విధంగా చాలా అన్వయములు
నేడు రూపొందించబడ్డాయి.

1920
01:24:47,080 --> 01:24:49,594
>> మనము తో వెళ్లాలని మీరు ఉండవచ్చు
మేము స్కేల్ అవుట్ చేసినప్పుడు ఈ ఉంది.

1921
01:24:49,594 --> 01:24:51,510
మేము ముందుకు వెళ్లి ఉంచుతాము
అక్కడికి ఎస్ 3 బకెట్.

1922
01:24:51,510 --> 01:24:54,200
మరియు ఆ S3 బకెట్, బదులుగా చేసేది
మా servers-- నుండి ఆ వస్తువులను

1923
01:24:54,200 --> 01:24:55,220
మేము ఆ పని చేయడు.

1924
01:24:55,220 --> 01:24:57,210
మీరు అన్ని మీ బైనరీ చాలు
మీ సర్వర్లపై వస్తువులు

1925
01:24:57,210 --> 01:24:59,751
మరియు మీరు ఆ సర్వర్ ఉపయోగించవచ్చు
సందర్భాలలో ఆ డేటా జైలుశిక్షను.

1926
01:24:59,751 --> 01:25:01,860
కానీ ఆ అందంగా ఖరీదైన ఉంది.

1927
01:25:01,860 --> 01:25:05,107
>> చేయడానికి మంచి మార్గం ముందుకు వెళ్ళి ఉంది
ఒక S3 బకెట్ లో ఆ వస్తువులు చాలు.

1928
01:25:05,107 --> 01:25:06,315
S3 ఒక వస్తువు రిపోజిటరీలను ఉంది.

1929
01:25:06,315 --> 01:25:10,860
ఇది ప్రత్యేకంగా నిర్మించిన
విషయాలు ఈ రకమైన అల్లడం.

1930
01:25:10,860 --> 01:25:13,690
మరియు ఆ ఖాతాదారులకు అభ్యర్థించవచ్చు వీలు
నేరుగా ఆ వస్తువు బకెట్లు నుండి,

1931
01:25:13,690 --> 01:25:15,390
సర్వర్లు విక్రయించాల్సి.

1932
01:25:15,390 --> 01:25:17,020
కాబట్టి మేము ఇక్కడ స్కేల్ అవుట్ మొదలు పెడుతున్నారు.

1933
01:25:17,020 --> 01:25:19,140
>> ఇప్పుడు మేము ప్రపంచవ్యాప్తంగా వినియోగదారులు వచ్చింది.

1934
01:25:19,140 --> 01:25:19,730
నేను వినియోగదారులు వచ్చింది.

1935
01:25:19,730 --> 01:25:23,380
నేను స్థానికంగా కంటెంట్ కలిగి ఉండాలి
కుడి, ఈ వినియోగదారులు దగ్గరగా ఉన్న?

1936
01:25:23,380 --> 01:25:26,200
నేను ఒక S3 బకెట్ సృష్టించాను
నా సోర్స్ రిపోజిటరీ.

1937
01:25:26,200 --> 01:25:29,370
నేను ముందు చేస్తాము ఆ
CloudFront పంపిణీ.

1938
01:25:29,370 --> 01:25:31,720
>> CloudFront ఒక CD మరియు ఒక
కంటెంట్ డెలివరీ నెట్వర్క్.

1939
01:25:31,720 --> 01:25:35,750
ప్రధానంగా మీరు పేర్కొనే డేటా పడుతుంది
మరియు ఇంటర్నెట్లో అన్ని కాషె

1940
01:25:35,750 --> 01:25:39,230
వినియోగదారులు ప్రతిచోటా అందుకోడానికి
చాలా త్వరగా స్పందించడం ఉన్నప్పుడు

1941
01:25:39,230 --> 01:25:40,960
వారు ఆ వస్తువుల అభ్యర్థించవచ్చు.

1942
01:25:40,960 --> 01:25:41,960
>> సో మీరు ఒక ఆలోచన పొందుటకు.

1943
01:25:41,960 --> 01:25:48,230
మీరు రకమైన పరపతి అన్ని
AWS యొక్క అన్ని అంశాలను ఇక్కడ ఈ పూర్తి చేయించడం అవసరం.

1944
01:25:48,230 --> 01:25:50,790
చివరకు, మేము త్రో
ఒక ఆటో స్కేలింగ్ సమూహంలో.

1945
01:25:50,790 --> 01:25:52,737
మా AC2 సందర్భాల్లో కాబట్టి
మా ఆట సర్వర్లు,

1946
01:25:52,737 --> 01:25:54,820
వారు busier పొందుటకు మొదలు
మరియు busier మరియు busier,

1947
01:25:54,820 --> 01:25:57,236
వారు కేవలం మరొక స్పిన్ చేస్తాము
ఉదాహరణకు, మరొక ఉదాహరణకు స్పిన్

1948
01:25:57,236 --> 01:25:58,210
మరో మచ్చుతునక స్పిన్.

1949
01:25:58,210 --> 01:26:02,090
AWS, ఇది ఉంది టెక్నాలజీ కాబట్టి
మీరు పరామితులను పేర్కొనడానికి అనుమతిస్తుంది

1950
01:26:02,090 --> 01:26:04,650
ఇది చుట్టూ మీ సర్వర్లు పెరగనుంది.

1951
01:26:04,650 --> 01:26:08,110
కాబట్టి మీరు సర్వర్లు n సంఖ్య కలిగి
ఏదైనా సమయంలో అక్కడ.

1952
01:26:08,110 --> 01:26:11,870
మీ లోడ్ వెళ్ళిపోతుంది ఉంటే, వారు చేస్తాము
కుదించే, సంఖ్య కుదించే చేస్తుంది.

1953
01:26:11,870 --> 01:26:15,250
మరియు లోడ్ తిరిగి వస్తే,
ఇది elastically, తిరిగి పెరుగుతాయి చేస్తాము.

1954
01:26:15,250 --> 01:26:17,050
>> కాబట్టి ఈ చాలా బాగుంది.

1955
01:26:17,050 --> 01:26:19,800
మేము ఇసి 2 సందర్భాల్లో చాలా వచ్చింది చేసిన.

1956
01:26:19,800 --> 01:26:21,671
మేము లో కాష్ ఉంచవచ్చు
డేటాబేస్ ముందు,

1957
01:26:21,671 --> 01:26:23,045
ప్రయత్నించండి మరియు డేటాబేస్ వేగవంతం.

1958
01:26:23,045 --> 01:26:25,030
తదుపరి ఒత్తిడి పాయింట్
సాధారణంగా ప్రజలు చూడండి

1959
01:26:25,030 --> 01:26:28,850
వారు ఒక ఉపయోగించి ఒక గేమ్ స్కేల్ ఉంది
రిలేషనల్ డేటాబేస్ వ్యవస్థ.

1960
01:26:28,850 --> 01:26:30,790
Jeez, డేటాబేస్
పనితీరు భయంకరమైన ఉంది.

1961
01:26:30,790 --> 01:26:31,932
ఎలా మేము చేస్తున్నాము మెరుగుపరచడానికి చెయ్యాలి?

1962
01:26:31,932 --> 01:26:33,640
యొక్క ఉంచడం ప్రయత్నించండి లెట్
ఆ ముందు కాష్.

1963
01:26:33,640 --> 01:26:36,780
>> Well, కాష్ పనిచేయదు
ఆటలలో గొప్ప, కుడి?

1964
01:26:36,780 --> 01:26:39,330
ఆటలు, రచన బాధాకరం.

1965
01:26:39,330 --> 01:26:40,930
గేమ్స్ చాలా భారీ రాయడానికి ఉంటాయి.

1966
01:26:40,930 --> 01:26:43,610
మీరు ఉన్నప్పుడు Cache పని లేదు
మీరు ఎల్లప్పుడూ చేసిన ఎందుకంటే భారీ రాయడానికి

1967
01:26:43,610 --> 01:26:44,610
కాష్ అప్డేట్ వచ్చింది.

1968
01:26:44,610 --> 01:26:47,780
మీరు ఇది, కాష్ అప్డేట్
అసంబద్ధం కాషింగ్ వుంటుంది.

1969
01:26:47,780 --> 01:26:49,780
ఇది నిజానికి కేవలం అదనపు పని.

1970
01:26:49,780 --> 01:26:51,970
>> కాబట్టి మేము ఇక్కడ వెళ్ళి ఎక్కడ?

1971
01:26:51,970 --> 01:26:54,400
మీరు ఒక పెద్ద ప్రతిబంధకంగా పొందారు
అక్కడ డౌన్ డేటాబేస్ లో.

1972
01:26:54,400 --> 01:26:57,661
మరియు స్థలాలకు వెళ్లడానికి
స్పష్టంగా విభజన ఉంది.

1973
01:26:57,661 --> 01:26:59,410
విభజన కాదు
మీరు ఉన్నప్పుడు చేయాలని సులభం

1974
01:26:59,410 --> 01:27:01,900
రిలేషనల్ డేటాబేస్ వ్యవహరించే.

1975
01:27:01,900 --> 01:27:05,080
రిలేషనల్ డేటాబేస్ తో, మీరు
నిర్వహణా బాధ్యత, సమర్థవంతంగా

1976
01:27:05,080 --> 01:27:06,210
కీ స్పేస్.

1977
01:27:06,210 --> 01:27:10,527
మీరు A మరియు M మధ్య ఏమంటున్నారు చేస్తున్నారు
N మరియు Z అక్కడ వెళ్ళి మధ్య ఇక్కడికి వెళ్ళండి.

1978
01:27:10,527 --> 01:27:12,360
మరియు మీరు మారే చేస్తున్నారు
అప్లికేషన్ అంతటా.

1979
01:27:12,360 --> 01:27:15,000
కాబట్టి మీరు వ్యవహరించే చేస్తున్నారు
ఈ విభజన డేటా మూలం.

1980
01:27:15,000 --> 01:27:18,670
మీరు లావాదేవీ అవరోధాల కలిగి
విభజనలను పరిధిలోకి లేదు.

1981
01:27:18,670 --> 01:27:20,560
మీరు అన్ని రకాల పొందారు
మీరు ఆ అవకతవకలు

1982
01:27:20,560 --> 01:27:23,040
అక్కడ ప్రయత్నిస్తున్న వ్యవహరించే
బయటకు స్కేలింగ్ ఎదుర్కోవటానికి

1983
01:27:23,040 --> 01:27:25,120
మరియు ఒక పెద్ద అవస్థాపనను నిర్మిస్తుంది.

1984
01:27:25,120 --> 01:27:27,284
ఇది కేవలం ఏ వినోదంగా.

1985
01:27:27,284 --> 01:27:30,930
>> ప్రేక్షకులు: సో మీరు ఆ చెప్తున్నావు
మూలం పాయింట్లు పెరుగుతున్న వేగం

1986
01:27:30,930 --> 01:27:31,430
ప్రక్రియ?

1987
01:27:31,430 --> 01:27:32,513
రిక్ HOULIHAN: పెరుగుతున్న?

1988
01:27:32,513 --> 01:27:33,520
ప్రేక్షకులు: మూల పాయింట్లు.

1989
01:27:33,520 --> 01:27:34,410
రిక్ HOULIHAN: మూల పాయింట్లు?

1990
01:27:34,410 --> 01:27:37,500
ప్రేక్షకులు: సమాచారం ఆధారంగా
పేరు సమాచారం నుండి వస్తోంది?

1991
01:27:37,500 --> 01:27:38,250
రిక్ HOULIHAN: నం

1992
01:27:38,250 --> 01:27:41,820
నేను చెప్పడం నేను పెరుగుతోంది
డేటా స్టోర్ విభజనలను సంఖ్య

1993
01:27:41,820 --> 01:27:44,060
నిర్గమాంశ మెరుగుపరుస్తుంది.

1994
01:27:44,060 --> 01:27:48,300
సో వాట్ ఇక్కడ జరుగుతున్నది వినియోగదారులు ఉంది
ఇక్కడ ఇసి 2 ఉదాహరణకు రావడం,

1995
01:27:48,300 --> 01:27:50,780
బాగా, నేను ఒక యూజర్ అవసరం ఉంటే
ఆ M ఒక, నేను ఇక్కడ వెళ్తారో.

1996
01:27:50,780 --> 01:27:53,560
N నుండి p, నేను ఇక్కడ వెళ్తారో.

1997
01:27:53,560 --> 01:27:55,060
Z కు P నుండి, నేను ఇక్కడ వెళ్తారో.

1998
01:27:55,060 --> 01:27:57,120
>> ప్రేక్షకులు: సరే, ఆ విధంగా ఉంటాయి
అన్ని వివిధ నోడ్స్ నిల్వ?

1999
01:27:57,120 --> 01:27:57,911
>> రిక్ HOULIHAN: అవును.

2000
01:27:57,911 --> 01:28:00,210
ఈ నాటికి థింక్
డేటా వివిధ గోతులు.

2001
01:28:00,210 --> 01:28:01,660
కాబట్టి, మీరు ఈ సమస్య.

2002
01:28:01,660 --> 01:28:02,910
మీరు ప్రయత్నిస్తున్న ఉంటే
ఈ మీరు ప్రయత్నిస్తున్న ఉంటే

2003
01:28:02,910 --> 01:28:05,730
ఒక రిలేషనల్ వేదికపై స్కేల్,
ఈ మీరు చేస్తున్న ఏమి ఉంది.

2004
01:28:05,730 --> 01:28:08,100
మీరు డేటా వేస్తున్నాము మరియు
మీరు నరకడం చేస్తున్నారు.

2005
01:28:08,100 --> 01:28:10,975
మరియు మీరు అది అంతటా విభజన చేస్తున్నారు
డేటాబేస్ అనేక చోట్ల.

2006
01:28:10,975 --> 01:28:13,580
మరియు మీరు అన్ని మేనేజింగ్ చేస్తున్న
అప్లికేషన్ వరుస వద్ద.

2007
01:28:13,580 --> 01:28:14,729
ఇది ఏ వినోదంగా.

2008
01:28:14,729 --> 01:28:15,770
కాబట్టి మనం వెళ్ళి అనుకుంటున్నారు?

2009
01:28:15,770 --> 01:28:20,240
మేము DynamoDB, పూర్తిగా నిర్వహించేది వెళ్లాలనుకుంటే,
NoSQL డేటా స్టోర్, నియమం నిర్గమాంశ.

2010
01:28:20,240 --> 01:28:22,680
మేము ఉన్నత సూచికలు ఉపయోగించండి.

2011
01:28:22,680 --> 01:28:26,154
ఇది ప్రాథమికంగా HTTP API మరియు
పత్రం మద్దతు ఇచ్చింది.

2012
01:28:26,154 --> 01:28:28,570
కాబట్టి మీరు ఆందోళన చెందనవసరం లేదు
విభజనీకరణ గురించి.

2013
01:28:28,570 --> 01:28:30,740
మేము మీరు కోసం అన్ని చేస్తాను.

2014
01:28:30,740 --> 01:28:33,260
కాబట్టి ఇప్పుడు, బదులుగా, మీరు
కేవలం పట్టిక వ్రాయండి.

2015
01:28:33,260 --> 01:28:36,490
పట్టిక విభజనకు కోరితే,
ఆ తెర వెనుక జరుగుతుంది.

2016
01:28:36,490 --> 01:28:40,642
మీరు పూర్తిగా ఇన్సులేట్ చేస్తున్నారు
ఒక డెవలపర్ గా నుండి.

2017
01:28:40,642 --> 01:28:42,350
కాబట్టి యొక్క మాట్లాడటానికి వీలు
వినియోగ సందర్భాలు కొన్ని

2018
01:28:42,350 --> 01:28:47,564
మేము గేమింగ్, సామాన్య లోకి అమలు
గేమింగ్ దృశ్యాలు, లీడర్.

2019
01:28:47,564 --> 01:28:49,980
కాబట్టి మీరు, వినియోగదారులు లో వస్తున్న పొందారు
వారు ఉన్నట్లు BoardNames

2020
01:28:49,980 --> 01:28:52,930
న, ఈ వినియోగదారుకు స్కోర్లు.

2021
01:28:52,930 --> 01:28:57,700
మేము userid న హ్యాషింగ్ ఉండవచ్చు
మరియు అప్పుడు మేము ఆట పరిధిని కలిగి ఉంటాయి.

2022
01:28:57,700 --> 01:28:59,960
కాబట్టి ప్రతి యూజర్ చూడండి కోరుకుంటున్నారు
అతను ఆడాడు అన్ని ఆట

2023
01:28:59,960 --> 01:29:01,770
మరియు అన్ని అతను అత్యధిక స్కోరు
అన్ని ఆట అంతటా.

2024
01:29:01,770 --> 01:29:04,000
కాబట్టి తన వ్యక్తిగత లీడర్బోర్డ్ వార్తలు.

2025
01:29:04,000 --> 01:29:10,010
>> ఇప్పుడు నేను వెళ్ళి కావలసిన మరియు నేను పొందవచ్చు కావలసిన
కాబట్టి నేను ఈ వ్యక్తిగత లీడర్బోర్డ్లను పొందండి.

2026
01:29:10,010 --> 01:29:12,827
నేను చేయాలనుకుంటున్నారా పొందండి గో
అన్ని వినియోగదారులు అంతటా టాప్ స్కోరు.

2027
01:29:12,827 --> 01:29:13,660
సో ఎలా నేను ఆ చేయాలి?

2028
01:29:13,660 --> 01:29:18,070
నా రికార్డు హ్యాష్ ఉన్నప్పుడు
userid, ఆట మధ్య,

2029
01:29:18,070 --> 01:29:20,740
బాగా నేను ముందుకు వెళ్ళి వెళుతున్న
మరియు పునర్నిర్మాణం, ఒక GSI సృష్టించడానికి

2030
01:29:20,740 --> 01:29:22,370
మరియు నేను ఆ డేటా పునరుద్ధరించుకునేందుకు వెళుతున్న.

2031
01:29:22,370 --> 01:29:27,310
>> ఇప్పుడు నేను హాష్ వెళుతున్న
ఆట ఇది BoardName.

2032
01:29:27,310 --> 01:29:29,800
మరియు నేను టాప్ స్కోర్ పరిధి వెళుతున్న.

2033
01:29:29,800 --> 01:29:31,540
మరియు ఇప్పుడు నేను వివిధ బకెట్లు సృష్టించాను.

2034
01:29:31,540 --> 01:29:34,790
నేను ఒకే పట్టిక ఉపయోగించి చేస్తున్నాను,
అదే అంశం డేటా.

2035
01:29:34,790 --> 01:29:39,870
కానీ నేను ఇచ్చే ఒక బకెట్ సృష్టించడం నేను
నాకు గేమ్ ద్వారా టాప్ స్కోర్ యొక్క సంకలనం.

2036
01:29:39,870 --> 01:29:43,180
>> నేను ఆ పట్టిక ప్రశ్నించడానికి
ఆ సమాచారాన్ని పొందడానికి.

2037
01:29:43,180 --> 01:29:50,890
కాబట్టి నేను ఆ ప్రశ్న నమూనా సెట్ చేసిన
ద్వితీయ ఇండెక్స్ ద్వారా మద్దతు ఇవ్వబడే.

2038
01:29:50,890 --> 01:29:54,556
ఇప్పుడు వారు BoardName ద్వారా వేరు చేయవచ్చు
మీద ఆధారపడి, TopScore ద్వారా క్రమబద్ధీకరించబడింది.

2039
01:29:54,556 --> 01:29:57,180
మీరు చూడగలరు కాబట్టి, ఈ రకాలు
మీరు గేమింగ్ లో పొందండి సందర్భాల్లో ఉపయోగం.

2040
01:29:57,180 --> 01:30:02,190
మేము గేమింగ్ లో పొందండి మరో మంచి ఉపయోగం విషయంలో
అవార్డులు మరియు ఎవరు అవార్డులు గెలుచుకుంది ఉంది.

2041
01:30:02,190 --> 01:30:05,340
మరియు ఈ ఒక గొప్ప ఉపయోగం సందర్భంలో
మేము అక్కడక్కడ సూచికలు కాల్.

2042
01:30:05,340 --> 01:30:07,340
స్పేర్సు నమోదుచేయ్యబడ్డ
ఉత్పత్తి సామర్ధ్యం

2043
01:30:07,340 --> 01:30:10,850
తప్పనిసరిగా లేని ఒక సూచిక
పట్టిక ప్రతి ఒక్క అంశం కలిగి.

2044
01:30:10,850 --> 01:30:11,470
ఎందుకు కాదు?

2045
01:30:11,470 --> 01:30:14,540
ఎందుకంటే చేయబడిన లక్షణం
ఇండెక్స్ ప్రతి అంశంపై ఉనికిలో లేదు.

2046
01:30:14,540 --> 01:30:16,460
>> ఈ కాబట్టి ముఖ్యంగా
సందర్భంలో ఉపయోగించడానికి, నేను చెప్పడం నేను,

2047
01:30:16,460 --> 01:30:19,240
మీరు ఏమి, నేను వెళుతున్న తెలుసు
అవార్డు అని ఒక లక్షణం సృష్టించడానికి.

2048
01:30:19,240 --> 01:30:22,970
మరియు నేను ప్రతి యూజర్ ఇవ్వాలని వెళుతున్న
కేటాయించండి ఇది ఒక బహుమానం ఉంది.

2049
01:30:22,970 --> 01:30:25,950
వినియోగదారులు పురస్కారములు లేని
ఆ లక్షణం కలిగి వెళ్ళడం లేదు.

2050
01:30:25,950 --> 01:30:27,800
నేను సృష్టించినప్పుడు
ఇండెక్స్, యూజర్లు మాత్రమే

2051
01:30:27,800 --> 01:30:28,960
ఆ చూపించడానికి వెళ్తున్నారు
సూచిక లో ఉన్నాయి

2052
01:30:28,960 --> 01:30:31,050
నిజానికి అవార్డులు గెలుచుకున్న ఆ వాటిని.

2053
01:30:31,050 --> 01:30:34,440
కాబట్టి ఆ చెయ్యగలరు ఒక గొప్ప మార్గం
ఫిల్టర్ సూచికలు రూపొందించడానికి ఆ

2054
01:30:34,440 --> 01:30:40,580
చేయలేని చాలా ప్రత్యేకమైనవి
ఇండెక్స్ మొత్తం పట్టికను కలిగి.

2055
01:30:40,580 --> 01:30:43,050
>> కాబట్టి మేము ఇక్కడ సమయం తక్కువగా చేస్తున్నారు.

2056
01:30:43,050 --> 01:30:49,190
నేను ముందుకు వెళ్లి skip వెళుతున్న
బయటకు మరియు ఈ దృష్టాంతంలో skip.

2057
01:30:49,190 --> 01:30:52,625
కొద్దిగా చర్చ గురించి

2058
01:30:52,625 --> 01:30:54,460
>> ప్రేక్షకులు: నేను ఒక శీఘ్ర ప్రశ్న అడగవచ్చా?

2059
01:30:54,460 --> 01:30:56,722
ఒక హెవీ వ్రాయండి?

2060
01:30:56,722 --> 01:30:57,680
రిక్ HOULIHAN: ఏమిటి?

2061
01:30:57,680 --> 01:30:58,596
ప్రేక్షకులు: భారీ వ్రాయండి.

2062
01:30:58,596 --> 01:31:01,270
రిక్ HOULIHAN: భారీ వ్రాయండి.

2063
01:31:01,270 --> 01:31:03,460
నన్ను చూడనివ్వండి.

2064
01:31:03,460 --> 01:31:06,220
>> ప్రేక్షకులు: లేదా అని కాదు
ఏదో మీరు కేవలం

2065
01:31:06,220 --> 01:31:08,809
సెకన్లు ఒక విషయంలో వాయిస్?

2066
01:31:08,809 --> 01:31:10,850
రిక్ HOULIHAN: మేము వెళ్ళి
ఓటింగ్ దృష్టాంతంలో ద్వారా.

2067
01:31:10,850 --> 01:31:11,670
ఇది ఆ చెడు కాదు.

2068
01:31:11,670 --> 01:31:14,580
మీరు అబ్బాయిలు కొన్ని నిమిషాల ఉందా?

2069
01:31:14,580 --> 01:31:15,860
అలాగే.

2070
01:31:15,860 --> 01:31:17,890
>> కాబట్టి మేము ఓటింగ్ గురించి మాట్లాడదాము.

2071
01:31:17,890 --> 01:31:20,250
సో నిజ సమయంలో ఓటింగ్, మేము కలిగి
ఓటింగ్ కోసం అవసరాలు.

2072
01:31:20,250 --> 01:31:25,250
అవసరాలు మనం అనుమతించే ఉన్నాయి
ప్రతి వ్యక్తి మాత్రమే ఒకసారి ఓటు.

2073
01:31:25,250 --> 01:31:28,060
మేము ఎవరూ చెయ్యగలరు అనుకుంటున్నారా
తమ ఓటు మార్చడానికి.

2074
01:31:28,060 --> 01:31:31,045
మేము నిజమైన సమయం అగ్రిగేషన్ కావలసిన
మరియు జనాభా కోసం విశ్లేషణలు

2075
01:31:31,045 --> 01:31:34,210
మనం చేయబోతున్నామని
సైట్ వినియోగదారుల చూపిస్తున్న.

2076
01:31:34,210 --> 01:31:35,200
>> ఈ అంశంలో ఆలోచించండి.

2077
01:31:35,200 --> 01:31:37,550
మేము రియాలిటీ చాలా పని
వారు ఎక్కడ TV చూపిస్తుంది

2078
01:31:37,550 --> 01:31:38,960
విషయాలు ఈ ఖచ్చితమైన రకం చేయడం.

2079
01:31:38,960 --> 01:31:41,584
కాబట్టి మీరు అంశంలో ఆలోచించవచ్చు,
మేము మిలియన్ల మరియు మిలియన్ల

2080
01:31:41,584 --> 01:31:43,959
అక్కడ యువ అమ్మాయిలు
వారి సెల్ ఫోన్ల తో

2081
01:31:43,959 --> 01:31:46,250
ఓటింగ్, ఓటింగ్, మరియు
వారు ఎవరైతే వోటు

2082
01:31:46,250 --> 01:31:48,610
అత్యంత ప్రజాదరణ అని కనిపెట్టారు.

2083
01:31:48,610 --> 01:31:50,830
కాబట్టి ఈ కొన్ని
అవసరాలు మనం రన్నవుట్.

2084
01:31:50,830 --> 01:31:52,990
>> కాబట్టి మొదటి పడుతుంది
ఈ సమస్య పరిష్కరించడంలో

2085
01:31:52,990 --> 01:31:55,090
ఒక నిర్మించడానికి ఉంటుంది
చాలా సాధారణ అప్లికేషన్.

2086
01:31:55,090 --> 01:31:56,490
కాబట్టి నేను ఈ అనువర్తనం పొందారు.

2087
01:31:56,490 --> 01:31:57,950
నేను అక్కడ కొన్ని ఓటర్లు తెలుసుకో.

2088
01:31:57,950 --> 01:31:59,980
వారు ఓటింగ్ అనువర్తనం హిట్, వస్తాయి.

2089
01:31:59,980 --> 01:32:03,440
నేను కొన్ని ముడి ఓట్లు పట్టిక పొందారు
నేను ఆ ఓట్లు లోకి డంప్ చేస్తాము.

2090
01:32:03,440 --> 01:32:05,780
నేను కొన్ని కంకర ఉంటుంది
ఓట్లు పట్టిక

2091
01:32:05,780 --> 01:32:09,490
నా విశ్లేషణలు మరియు జనాభా వివరాలు చేస్తాను,
మరియు మేము అక్కడ అన్ని ఈ ఉంచుతాము.

2092
01:32:09,490 --> 01:32:11,420
>> మరియు ఈ గొప్ప.

2093
01:32:11,420 --> 01:32:12,332
జీవితం చాల బాగుంది.

2094
01:32:12,332 --> 01:32:15,040
లైఫ్ యొక్క మేము తెలుసుకుని వరకు మంచి
ఎల్లప్పుడూ మాత్రమే ఒకటి లేదా రెండు ఉంది

2095
01:32:15,040 --> 01:32:16,879
ఎన్నికల జనరంజకమైన ప్రజలు.

2096
01:32:16,879 --> 01:32:19,420
కేవలం ఒకటి లేదా రెండు విషయాలు ఉన్నాయి
ప్రజలు నిజంగా పట్టించుకోనట్లు.

2097
01:32:19,420 --> 01:32:22,340
మరియు మీరు వద్ద ఓటు చేస్తుంటే
స్థాయి, నేను అకస్మాత్తుగా అన్ని

2098
01:32:22,340 --> 01:32:26,360
బయటకు నరకం hammering కావడం
రెండు అభ్యర్థులు, ఒకటి లేదా రెండు అభ్యర్థులు.

2099
01:32:26,360 --> 01:32:29,390
అంశాల చాలా పరిమిత సంఖ్యలో
ప్రజలు జనరంజక అని కనిపెట్టారు.

2100
01:32:29,390 --> 01:32:31,710
>> ఈ ఒక మంచి డిజైన్ నమూనా కాదు.

2101
01:32:31,710 --> 01:32:33,549
ఈ నిజానికి ఒక ఉంది
చాలా చెడ్డ రూపకల్పన నమూనా

2102
01:32:33,549 --> 01:32:36,340
ఇది సృష్టిస్తుంది ఎందుకంటే వేటి మేము
వేడి కీలు ఉంది గురించి మాట్లాడారు.

2103
01:32:36,340 --> 01:32:38,960
హాట్ కీలు మేము నచ్చని ఏదో ఉంటాయి.

2104
01:32:38,960 --> 01:32:40,470
>> కాబట్టి మేము ఎలా ఆ పరిష్కరించాలి?

2105
01:32:40,470 --> 01:32:47,640
మరియు నిజంగా, ఈ పరిష్కరించడానికి మార్గం
ఆ అభ్యర్థి బకెట్లు తీసుకొని

2106
01:32:47,640 --> 01:32:51,490
మరియు మేము ప్రతి అభ్యర్థి,
మనం ఒక యాదృచ్చిక విలువ జోడించే చూడాలని,

2107
01:32:51,490 --> 01:32:54,192
యాదృచ్ఛిక మేము తెలుసు ఏదో,
ఒక మరియు 100 మధ్య విలువ,

2108
01:32:54,192 --> 01:32:56,620
100 మరియు 1,000 మధ్య,
లేదా ఒక మరియు 1,000 మధ్య,

2109
01:32:56,620 --> 01:32:59,940
అయితే అనేక యాదృచ్ఛిక విలువలు మీకు కావలసిన
ఆ అభ్యర్థి ముగింపు లో కలపవచ్చు.

2110
01:32:59,940 --> 01:33:01,330
>> నేను నిజంగా అప్పుడు ఏమి చేసారు?

2111
01:33:01,330 --> 01:33:05,830
నేను అభ్యర్థి ID గా ఉపయోగించి చేస్తున్నాను ఉంటే
మొత్తం ఓట్లు బకెట్,

2112
01:33:05,830 --> 01:33:08,780
నేను ఒక యాదృచ్ఛిక జోడించిన ఉంటే
ఆ చివర సంఖ్య,

2113
01:33:08,780 --> 01:33:12,000
నేను సృష్టించాను ఇప్పుడు 10 బక్కెట్లు, ఒక
వంద బక్కెట్లు, వెయ్యి బకెట్లు

2114
01:33:12,000 --> 01:33:14,160
నేను అంతటా ఓట్లు సంకలనం చేస్తున్నాను.

2115
01:33:14,160 --> 01:33:18,030
>> కాబట్టి నేను మిలియన్ల మరియు మిలియన్ల కలిగి
మరియు రికార్డులు లక్షలాది వస్తున్న

2116
01:33:18,030 --> 01:33:22,050
ఈ అభ్యర్థులకు, నేను ఇప్పుడు వ్యాప్తి చేస్తున్నాను
అభ్యర్థి A_1 అంతటా ఆ ఓట్లు

2117
01:33:22,050 --> 01:33:24,630
అభ్యర్థి A_100 ద్వారా, ఎందుకంటే
ఒక ఓటు వస్తుంది ప్రతిసారీ,

2118
01:33:24,630 --> 01:33:26,530
నేను ఒక యాదృచ్ఛిక ఉత్పత్తి చేస్తున్నాను
ఒక మరియు 100 మధ్య విలువ.

2119
01:33:26,530 --> 01:33:29,446
నేను ముగింపు మీదకు tacking చేస్తున్నాను
వ్యక్తి యొక్క వోటు ఆ అభ్యర్థి.

2120
01:33:29,446 --> 01:33:31,120
నేను ఆ బకెట్ లోకి డంపింగ్ చేస్తున్నాను.

2121
01:33:31,120 --> 01:33:33,910
>> ఇప్పుడు వెనకవీపు న, నాకు తెలుసు
ఆ నేను ఒక వంద బకెట్లు వచ్చింది.

2122
01:33:33,910 --> 01:33:36,350
నేను ముందుకు వెళ్లాలని మీరు ఎప్పుడు
ఓట్ల సమగ్రం,

2123
01:33:36,350 --> 01:33:38,244
నేను అన్ని ఆ బకెట్లు నుండి చదవండి.

2124
01:33:38,244 --> 01:33:39,160
నేను ముందుకు వెళ్లి జోడించండి.

2125
01:33:39,160 --> 01:33:42,410
ఆపై నేను చెల్లాచెదరు సేకరించడానికి లేదు
నేను బయటకు వెళ్లి హే చెప్పే పేరు,

2126
01:33:42,410 --> 01:33:45,399
మీకు తెలిసిన ఏమి, ఈ అభ్యర్థి కీ
ఖాళీలు వంద బకెట్లు ఉంది.

2127
01:33:45,399 --> 01:33:47,940
నేను అన్ని సేకరించడానికి వెళుతున్న
ఆ వంద బకెట్లు నుండి ఓట్ చేస్తారు.

2128
01:33:47,940 --> 01:33:49,981
నేను సమష్టి వెళుతున్న
వాటిని మరియు నేను చెప్పడానికి వెళుతున్నాను

2129
01:33:49,981 --> 01:33:53,830
అభ్యర్థి ఇప్పుడు
x యొక్క మొత్తం ఓట్ల లెక్కింపు.

2130
01:33:53,830 --> 01:33:55,690
>> ఇప్పుడు వ్రాయండి రెండు
ప్రశ్న మరియు రీడ్ ప్రశ్న

2131
01:33:55,690 --> 01:33:58,160
చక్కగా పంపిణీ చేస్తారు
నేను అంతటా వ్రాయడం వెబ్ ఎందుకంటే

2132
01:33:58,160 --> 01:34:00,320
మరియు నేను కీలు వందల వింటున్నాను.

2133
01:34:00,320 --> 01:34:03,500
నేను వ్రాసే కాదు మరియు
ఇప్పుడు ఒక కీ అంతటా చదవడం.

2134
01:34:03,500 --> 01:34:04,950
కాబట్టి ఒక గొప్ప నమూనా.

2135
01:34:04,950 --> 01:34:08,090
>> ఈ నిజానికి బహుశా ఒకటి
అతి ముఖ్యమైన డిజైన్

2136
01:34:08,090 --> 01:34:10,420
NoSQL లో స్థాయిలో కోసం నమూనాలు.

2137
01:34:10,420 --> 01:34:14,470
మీరు ఈ రకం చూస్తారు
ప్రతి రుచి ఆకృతిని.

2138
01:34:14,470 --> 01:34:19,100
MongoDB, DynamoDB, అది లేదు
విషయం, మేము అన్ని ఈ లేదు.

2139
01:34:19,100 --> 01:34:21,840
మీరు వ్యవహరించే చేసినప్పుడు ఎందుకంటే
ఆ భారీ aggregations తో,

2140
01:34:21,840 --> 01:34:26,650
మీరు ఒక మార్గం దొరుకుతుందని కలిగి
బకెట్లు అంతటా వాటిని వ్యాప్తి.

2141
01:34:26,650 --> 01:34:29,512
కాబట్టి ఈ మీరు అలా మార్గం.

2142
01:34:29,512 --> 01:34:31,220
అన్ని కుడి, కాబట్టి ఏమి
మీరు ప్రస్తుతం చేస్తున్న

2143
01:34:31,220 --> 01:34:35,252
చదువు ట్రేడింగ్ ఆఫ్ ఉన్నాము ఉంది
వ్రైట్ వ్యాప్తిని ఖర్చు.

2144
01:34:35,252 --> 01:34:37,085
నా రీడ్ ఖర్చు
కొంచెం క్లిష్టమైన

2145
01:34:37,085 --> 01:34:40,220
మరియు నేను ఒక నుండి చదవడానికి వెళ్ళాలి
వంద బకెట్లు ఒకటి బదులు.

2146
01:34:40,220 --> 01:34:41,310
కానీ నేను వ్రాయడానికి అనుకోవడం ఉన్నాను.

2147
01:34:41,310 --> 01:34:44,860
మరియు నా నిర్గమాంశ, నా వ్రాయండి
నిర్గమాంశ అద్భుతమైన ఉంది.

2148
01:34:44,860 --> 01:34:49,450
కనుక ఇది సాధారణంగా ఒక విలువైన
DynamoDB స్కేలింగ్ కోసం టెక్నిక్,

2149
01:34:49,450 --> 01:34:51,350
లేదా ఆ విషయం కొరకు ఏ NoSQL డేటాబేస్.

2150
01:34:51,350 --> 01:34:53,824

2151
01:34:53,824 --> 01:34:55,240
కాబట్టి మేము ఇది స్కేల్ ఎలా కనుగొన్నారు.

2152
01:34:55,240 --> 01:34:56,930
మరియు మేము చిత్రవిచిత్రమైన ఎలా
మా వేడి కీలు తొలగించే.

2153
01:34:56,930 --> 01:34:57,820
మరియు ఈ అద్భుతమైన ఉంది.

2154
01:34:57,820 --> 01:34:58,960
మరియు మేము ఈ nice వ్యవస్థ వచ్చింది.

2155
01:34:58,960 --> 01:35:02,043
మరియు అది మాకు చాలా సరైన ఓటింగ్ అందించిందని
ఈ రికార్డ్ ఓటు డి-మోసగించు ఎందుకంటే.

2156
01:35:02,043 --> 01:35:03,130
ఇది DynamoDB లోకి నిర్మించిన.

2157
01:35:03,130 --> 01:35:05,380
మేము నియత హక్కుల గురించి మాట్లాడారు.

2158
01:35:05,380 --> 01:35:08,170
>> ఓటరు వచ్చినప్పుడే ఉంచుతుంది
పట్టిక ఒక చొప్పించు,

2159
01:35:08,170 --> 01:35:11,220
వారు వారి ఓటర్ ID లతో ఇన్సర్ట్
వారు మరొక ఓటు ఇన్సర్ట్ చెయ్యడానికి ప్రయత్నించండి ఉంటే,

2160
01:35:11,220 --> 01:35:13,320
నేను ఒక నియత వ్రాస్తారా.

2161
01:35:13,320 --> 01:35:16,960
ఈ వ్రాయడానికి మాత్రమే సే
ఈ ఉనికిలో లేదు ఉంటే.

2162
01:35:16,960 --> 01:35:19,270
అందుకే వెంటనే ఆ చూడుము
ఆ ఓటు యొక్క పట్టిక హిట్,

2163
01:35:19,270 --> 01:35:20,460
ఎవ్వరూ చేస్తాడు
తమ ఓటు ఉంచారు సాధించారు.

2164
01:35:20,460 --> 01:35:21,634
మరియు ఆ అద్భుతమైన ఉంది.

2165
01:35:21,634 --> 01:35:23,550
మరియు మేము పెంచడం చేస్తున్నారు
మా అభ్యర్థి కౌంటర్లు.

2166
01:35:23,550 --> 01:35:25,466
మరియు మేము మా చేస్తున్నా
జనాభా మరియు అన్ని ఆ.

2167
01:35:25,466 --> 01:35:29,110
కానీ ఏం జరుగుతుంది నా
అప్లికేషన్ పై పడుతుంది?

2168
01:35:29,110 --> 01:35:31,350
ఇప్పుడు అకస్మాత్తుగా ఓట్ల అన్ని
వస్తున్న ఉన్నాయి, మరియు నేను

2169
01:35:31,350 --> 01:35:34,840
వారు ప్రాసెస్ పొందుతుంటే తెలియదు
నా విశ్లేషణలు మరియు జనాభా లోకి

2170
01:35:34,840 --> 01:35:36,040
ఇకపై.

2171
01:35:36,040 --> 01:35:38,462
ఎప్పుడు అప్లికేషన్
అప్, ఎలా తిరిగి వస్తుంది

2172
01:35:38,462 --> 01:35:41,420
నరకం నేను ఓట్లు ఏమి తెలుసు
ప్రాసెస్ చేసిన మరియు నేను మొదలు లేదు?

2173
01:35:41,420 --> 01:35:44,530
>> కాబట్టి ఈ నిజమైన సమస్య ఉన్నప్పుడు మీరు
దృష్టాంతంలో ఈ రకం వద్ద చూడండి ప్రారంభించండి.

2174
01:35:44,530 --> 01:35:45,571
మరియు ఎలా మేము ఆ పరిష్కారం లేదు?

2175
01:35:45,571 --> 01:35:48,070
మేము ఏమి తో పరిష్కరించడానికి మేము
DynamoDB Streams కాల్.

2176
01:35:48,070 --> 01:35:53,470
Streams ఒక సమయం ఆదేశించారు మరియు
ప్రతి ప్రవేశ యొక్క విభజించబడిన మార్పు లాగ్

2177
01:35:53,470 --> 01:35:55,700
పట్టిక, ప్రతి వ్రాయడానికి
పట్టిక యాక్సెస్.

2178
01:35:55,700 --> 01:35:58,810
వ్రాసిన ఏ డేటా
పట్టిక స్ట్రీమ్లో అప్ చూపిస్తుంది.

2179
01:35:58,810 --> 01:36:01,815
>> ఇది ప్రాథమికంగా ఒక 24 గంటల క్యూ ఉంది.

2180
01:36:01,815 --> 01:36:03,690
అంశాలు స్ట్రీమ్ హిట్,
వారు 24 గంటలు నివసిస్తున్నారు.

2181
01:36:03,690 --> 01:36:05,990
వారు అనేకసార్లు చదవవచ్చు.

2182
01:36:05,990 --> 01:36:09,400
పంపబడతాయి హామీ
మాత్రమే స్ట్రీమ్ ఒకసారి,

2183
01:36:09,400 --> 01:36:11,180
సార్లు n సంఖ్య చదవగలిగిన.

2184
01:36:11,180 --> 01:36:14,910
కనుక అయితే అనేక ప్రక్రియలు మీరు కావలసిన
ఆ డేటా తినే, మీరు తింటారు.

2185
01:36:14,910 --> 01:36:16,350
ఇది ప్రతి నవీకరణ కనిపిస్తుంది.

2186
01:36:16,350 --> 01:36:18,455
ప్రతి వ్రాయడానికి మాత్రమే
స్ట్రీమ్లో ఒకసారి కనిపిస్తాయి.

2187
01:36:18,455 --> 01:36:20,621
కాబట్టి మీరు ఆందోళన చెందనవసరం లేదు
రెండుసార్లు దీన్ని ప్రాసెస్ గురించి

2188
01:36:20,621 --> 01:36:22,500
అదే ప్రక్రియ నుండి.

2189
01:36:22,500 --> 01:36:25,350
>> ఇది ఖచ్చితంగా అంశం ప్రతి ఆదేశించింది లో.

2190
01:36:25,350 --> 01:36:28,180
మేము సమయం చెప్పినప్పుడు
ఆదేశించారు మరియు విభజించబడిన,

2191
01:36:28,180 --> 01:36:30,680
మీరు స్ట్రీమ్ విభజన శాతం చూస్తారు.

2192
01:36:30,680 --> 01:36:33,169
మీరు క్రమంలో అంశాలను, నవీకరణలను చూస్తారు.

2193
01:36:33,169 --> 01:36:35,210
మేము హామీ లేదు
మీరు ఆ స్ట్రీమ్లో

2194
01:36:35,210 --> 01:36:40,240
ప్రతి లావాదేవీ పొందగలిగిన
అంశాలను అంతటా క్రమంలో.

2195
01:36:40,240 --> 01:36:42,440
>> కాబట్టి ప్రవాహాలు మార్పురహిత ఉన్నాయి.

2196
01:36:42,440 --> 01:36:44,037
మేము అన్ని మార్పురహిత అర్థం ఏమి తెలుసు?

2197
01:36:44,037 --> 01:36:46,620
మార్పురహిత మీరు దీన్ని చెయ్యవచ్చు అర్థం
పైగా, మరియు పైగా మరియు పైగా మళ్ళీ.

2198
01:36:46,620 --> 01:36:48,200
ఫలితం అదే చేస్తాడు.

2199
01:36:48,200 --> 01:36:49,991
>> ప్రసారాలు, మార్పురహిత ఉంటాయి
కానీ వారు ఉండాలి

2200
01:36:49,991 --> 01:36:54,860
ప్రారంభ స్థానం నుండి ఆడాడు,
మీరు ఎంచుకున్న ఎక్కడ, చివర,

2201
01:36:54,860 --> 01:36:57,950
లేదా వారు ఫలితాన్ని ఇవ్వదు
అదే విలువలలో.

2202
01:36:57,950 --> 01:36:59,727
>> MongoDB ఇదే.

2203
01:36:59,727 --> 01:37:01,560
MongoDB నిర్మాణం ఉంది
వారు oplog కాల్.

2204
01:37:01,560 --> 01:37:04,140
ఇది ఖచ్చితమైన అదే నిర్మాణం.

2205
01:37:04,140 --> 01:37:06,500
అనేక NoSQL డేటాబేస్
ఈ నిర్మాణం చేసారు.

2206
01:37:06,500 --> 01:37:08,790
వారు పనులను దాన్ని ఉపయోగించండి
వంటి ప్రతికృతి, ఇది

2207
01:37:08,790 --> 01:37:10,475
ఖచ్చితంగా మేము ప్రవాహాలు చేసేది.

2208
01:37:10,475 --> 01:37:12,350
ప్రేక్షకులు: బహుశా ఒక
వారైనా ప్రశ్న, కానీ మీరు

2209
01:37:12,350 --> 01:37:13,975
అనువర్తనాలను ఒక మొదలగునవి డౌన్ చేయడం గురించి మాట్లాడటానికి.

2210
01:37:13,975 --> 01:37:16,089
ప్రవాహాలు హామీ
బహుశా డౌన్ వెళ్ళి ఎప్పటికీ?

2211
01:37:16,089 --> 01:37:18,630
రిక్ HOULIHAN: అవును, వాగులు
డౌన్ వెళ్ళి ఎప్పుడూ హామీ ఇచ్చారు.

2212
01:37:18,630 --> 01:37:21,040
మేము అవస్థాపన నిర్వహించండి
వెనుక. స్వయంచాలకంగా ప్రవాహాలు

2213
01:37:21,040 --> 01:37:22,498
ఆటోమొబైల్ స్కేలింగ్ సమూహంలో నియమించుకుంటాయి.

2214
01:37:22,498 --> 01:37:25,910
మేము కొద్దిగా ద్వారా వెళ్తారో
ఏమి గురించి బిట్.

2215
01:37:25,910 --> 01:37:30,060
>> నేను వారు కాదని చెప్పడానికి కాదు
డౌన్ వెళ్ళి ఎప్పటికీ హామీ.

2216
01:37:30,060 --> 01:37:33,110
అంశాలు హామీ
స్ట్రీమ్ కనిపించడం.

2217
01:37:33,110 --> 01:37:36,740
మరియు స్ట్రీమ్ అందుబాటులో ఉంటుంది.

2218
01:37:36,740 --> 01:37:40,580
సో వాట్ చెయ్యకపోతే లేదా తిరిగి వస్తుంది
అప్, ఆ కింద జరుగుతుంది.

2219
01:37:40,580 --> 01:37:43,844
ఇది సరే covers--.

2220
01:37:43,844 --> 01:37:46,260
అన్ని కుడి, మీరు వివిధ పొందుటకు కాబట్టి
తెరవెనుక వీక్షణ రకాల.

2221
01:37:46,260 --> 01:37:51,040
ఒక ముఖ్యమైన వీక్షణ రకాల
ప్రోగ్రామర్ సాధారణంగా ఇది ఏమి ఉన్నాయి?

2222
01:37:51,040 --> 01:37:52,370
నేను పాత వీక్షణ పొందండి.

2223
01:37:52,370 --> 01:37:55,630
ఒక నవీకరణ పట్టిక తాకినప్పుడు, అది చేస్తాము
కాలువలోకి పాత వీక్షణ పుష్

2224
01:37:55,630 --> 01:38:02,070
కాబట్టి డేటా ఆర్కైవ్, లేదా మార్పు చేయవచ్చు
నియంత్రణ, మార్పు గుర్తింపు, మార్పు

2225
01:38:02,070 --> 01:38:03,600
నిర్వహణ.

2226
01:38:03,600 --> 01:38:07,160
>> ఇది తర్వాత ఇప్పుడు ఏ కొత్త చిత్రం,
వీక్షణ మరొక రకం ఆ నవీకరణ,

2227
01:38:07,160 --> 01:38:07,660
మీరు పొందవచ్చు.

2228
01:38:07,660 --> 01:38:09,660
మీరు పాత మరియు కొత్త చిత్రాలను పొందవచ్చు.

2229
01:38:09,660 --> 01:38:10,660
బహుశా నేను వాటిని రెండు కావలసిన.

2230
01:38:10,660 --> 01:38:11,790
నేను ఇది ఏమి చూడాలనుకుంటే.

2231
01:38:11,790 --> 01:38:13,290
నేను మార్చారు ఏమి చూడాలనుకుంటే.

2232
01:38:13,290 --> 01:38:15,340
>> నేను ఒక అంగీకార రకం కలిగి
ప్రక్రియ యొక్క నడుస్తుంది.

2233
01:38:15,340 --> 01:38:17,430
ఇది ధ్రువీకరించడం అవసరం
ఈ విషయాలు మారినప్పుడు,

2234
01:38:17,430 --> 01:38:21,840
వారు కొన్ని పరిమితులు లోపల అని
లేదా కొన్ని పారామితులు లోపల.

2235
01:38:21,840 --> 01:38:23,840
>> మరియు అప్పుడు నేను మాత్రమే
మార్చింది తెలుసుకోవాలి.

2236
01:38:23,840 --> 01:38:26,240
నేను మార్చబడింది ఏమి అంశం పట్టించుకోను.

2237
01:38:26,240 --> 01:38:28,580
నేను తెలుసుకోవాలి అవసరం లేదు
ఏం మారింది ఆపాదించాడు.

2238
01:38:28,580 --> 01:38:30,882
నేను ఆ తెలుసుకోవాలి
అంశాలను తాకిన చేస్తున్నారు.

2239
01:38:30,882 --> 01:38:33,340
కాబట్టి ఈ అభిప్రాయాలలో రకాలు
మీరు స్ట్రీమ్ ఆఫ్ పొందుటకు

2240
01:38:33,340 --> 01:38:35,960
మరియు మీరు వ్యవహరించవచ్చు.

2241
01:38:35,960 --> 01:38:37,840
>> అప్లికేషన్ ఆ
స్ట్రీమ్ ఖర్చవుతుంది,

2242
01:38:37,840 --> 01:38:39,298
ఈ పనిచేస్తుంది మార్గం యొక్క రకం.

2243
01:38:39,298 --> 01:38:42,570
DynamoDB క్లయింట్ అడగండి
పట్టికలు డేటా పుష్.

2244
01:38:42,570 --> 01:38:44,750
Streams మేము ముక్కలు కాల్ ఏమి విస్తరించడానికి.

2245
01:38:44,750 --> 01:38:47,380
ముక్కలు స్కేల్ ఉంటాయి
స్వతంత్రంగా పట్టిక.

2246
01:38:47,380 --> 01:38:50,660
వారు పూర్తిగా వరుసలో లేదు
మీ పట్టిక విభజనల.

2247
01:38:50,660 --> 01:38:52,540
మరియు కారణం ఎందుకు
వారు వరుసలో ఎందుకంటే

2248
01:38:52,540 --> 01:38:55,430
సామర్థ్యం, ​​ప్రస్తుత
పట్టిక సామర్థ్యం.

2249
01:38:55,430 --> 01:38:57,600
>> వారు విస్తరించడానికి తమ
సొంత ఆటో స్కేలింగ్ సమూహం,

2250
01:38:57,600 --> 01:39:00,800
మరియు వారు బట్టి స్పిన్ మొదలు
వస్తున్న ఎన్ని వ్రాస్తూ,

2251
01:39:00,800 --> 01:39:03,090
ఎన్ని reads-- నిజంగా అది వ్రాస్తాడు.

2252
01:39:03,090 --> 01:39:05,820
అక్కడ ఎటువంటి reads-- కానీ ఎలా
అనేక వ్రాస్తూ వస్తున్నాయి.

2253
01:39:05,820 --> 01:39:08,200
>> ఆపై వెనుక
ముగింపు మనం ఏమి మేము

2254
01:39:08,200 --> 01:39:11,390
ఒక KCL, లేదా చలనము క్లయింట్ లైబ్రరీ కాల్.

2255
01:39:11,390 --> 01:39:19,190
చలనము ఒక ప్రవాహం డేటా
అమెజాన్ నుండి ప్రాసెసింగ్ టెక్నాలజీ.

2256
01:39:19,190 --> 01:39:22,040
మరియు ఆ ప్రవాహాలు లో నిర్మించబడింది.

2257
01:39:22,040 --> 01:39:25,670
>> సో మీరు ఒక KCL ఎనేబుల్ ఉపయోగించడానికి
అప్లికేషన్ స్ట్రీమ్ చదవడానికి.

2258
01:39:25,670 --> 01:39:28,752
చలనము క్లయింట్ లైబ్రరీ నిజానికి
మీరు కోసం కార్మికులు నిర్వహిస్తుంది.

2259
01:39:28,752 --> 01:39:30,460
మరియు అది కూడా కొన్ని చేస్తుంది
ఆసక్తికరమైన విషయాలు.

2260
01:39:30,460 --> 01:39:35,630
ఇది కొన్ని పట్టికలు అప్ సృష్టిస్తుంది
మీ DynamoDB tablespace లో

2261
01:39:35,630 --> 01:39:38,410
ఇది అంశాలను ట్రాక్
ప్రాసెస్ చేయబడ్డారు.

2262
01:39:38,410 --> 01:39:41,190
కాబట్టి ఈ విధంగా ఉంటే, తిరిగి పడిపోతే
అది పైగా వస్తుంది మరియు వస్తుంది మరియు గెట్స్

2263
01:39:41,190 --> 01:39:45,570
తిరిగి పైకి నిలిచి, అది ఎక్కడ గుర్తించడానికి చేయవచ్చు
స్ట్రీమ్ ప్రాసెసింగ్ ఇది.

2264
01:39:45,570 --> 01:39:48,360
>> ఆ తర్వాత చాలా ముఖ్యం
మీరు ప్రతికృతి గురించి మాట్లాడటం చేస్తున్నాం.

2265
01:39:48,360 --> 01:39:50,350
నేను ఏమి చేయాలి
డేటా ప్రాసెస్ చేసిన జరిగినది

2266
01:39:50,350 --> 01:39:52,810
ఏ డేటా ఇంకా ప్రాసెస్ వుంటుంది.

2267
01:39:52,810 --> 01:39:57,380
కాబట్టి ప్రవాహాలు కోసం KCL లైబ్రరీ రెడీ
మీరు కార్యాచరణను ఇచ్చాయి.

2268
01:39:57,380 --> 01:39:58,990
ఇది అన్ని శుభ్రపరచటం యొక్క జాగ్రత్త తీసుకుంటుంది.

2269
01:39:58,990 --> 01:40:01,140
ఇది ప్రతి పెంకు ఒక కార్మికుడు వరకు నిలుస్తుంది.

2270
01:40:01,140 --> 01:40:04,620
ఇది ఒక పరిపాలక పట్టిక సృష్టిస్తుంది
ప్రతి కార్మికుడు ప్రతి పెంకు కోసం.

2271
01:40:04,620 --> 01:40:07,560
మరియు ఆ కార్మికులకు అగ్ని,
వారు ఆ పట్టికలు నిర్వహించడానికి

2272
01:40:07,560 --> 01:40:10,510
కాబట్టి మీరు ఈ రికార్డ్ తెలుసు
చదివి ప్రాసెస్ అయ్యింది.

2273
01:40:10,510 --> 01:40:13,850
మరియు ఆ విధంగా ప్రక్రియ ఉంటే
మరణిస్తాడు మరియు ఆన్లైన్ తిరిగి వస్తుంది

2274
01:40:13,850 --> 01:40:17,940
అది బయలుదేరాడు పేరు కుడి చేసుకోగలుగుతారు.

2275
01:40:17,940 --> 01:40:20,850
>> కాబట్టి మేము ఈ ఉపయోగించడానికి
క్రాస్ ప్రాంతంలో రిప్లికేషన్.

2276
01:40:20,850 --> 01:40:24,680
వినియోగదారులు చాలా అవసరం కలిగి
వారి డేటా పట్టికలు డేటా లేదా భాగాలు కదిలించాల్సిన

2277
01:40:24,680 --> 01:40:25,920
చుట్టూ వివిధ ప్రాంతాలకు.

2278
01:40:25,920 --> 01:40:29,230
తొమ్మిది ప్రాంతాలు ఉన్నాయి
అన్ని ప్రపంచవ్యాప్తంగా.

2279
01:40:29,230 --> 01:40:32,100
సో ఒక వాటిని అవసరం నేను ఉండవచ్చు
ఆసియా లోని వాడుకర్లకు ఉండవచ్చు, వినియోగదారులు

2280
01:40:32,100 --> 01:40:34,150
యునైటెడ్ స్టేట్స్ యొక్క ఈస్ట్ కోస్ట్ లో.

2281
01:40:34,150 --> 01:40:38,980
వారు వివిధ డేటా కలిగి
స్థానికంగా పంపిణీ చేయాల్సిన అవసరముంది.

2282
01:40:38,980 --> 01:40:42,510
మరియు బహుశా ఒక వినియోగదారు నుండి ఎగురుతూ
యునైటెడ్ స్టేట్స్ ఆసియా,

2283
01:40:42,510 --> 01:40:45,020
మరియు నేను నకలు అనుకుంటే
అతనితో తన డేటా.

2284
01:40:45,020 --> 01:40:49,340
అతను విమానం ఆఫ్ పొందినప్పుడు, అతను ఉంది
తన మొబైల్ అనువర్తనం ఉపయోగించి ఒక మంచి అనుభవం.

2285
01:40:49,340 --> 01:40:52,360
>> మీరు క్రాస్ ప్రాంతంలో ఉపయోగించవచ్చు
ప్రతికృతి లైబ్రరీ దీన్ని.

2286
01:40:52,360 --> 01:40:55,730
సాధారణంగా మనం
రెండు సాంకేతిక పరిజ్ఞానము.

2287
01:40:55,730 --> 01:40:59,400
వన్ మీరు చెయ్యవచ్చు ఒక కన్సోల్ వినియోగానికి వార్తలు
మీ స్వంత ఇసి 2 ఇన్స్టాన్సుపై స్టాండ్ అప్.

2288
01:40:59,400 --> 01:41:01,240
ఇది స్వచ్ఛమైన ప్రతికృతి నడుస్తుంది.

2289
01:41:01,240 --> 01:41:02,720
మరియు తర్వాత మేము లైబ్రరీ ఇచ్చారు.

2290
01:41:02,720 --> 01:41:06,070
లైబ్రరీ మీరు నిర్మించడానికి ఉపయోగించవచ్చు
మీ స్వంత అనువర్తనం మీరు ఉంటే

2291
01:41:06,070 --> 01:41:10,740
ఆ వెర్రి విషయాలు చేయాలనుకుంటున్నారా data--
వడపోత, అది మాత్రమే భాగంగా నకలు

2292
01:41:10,740 --> 01:41:14,120
డేటా రొటేట్ ఒక లోకి తరలించే
వివిధ పట్టిక, అందువలన న మొదలగునవి.

2293
01:41:14,120 --> 01:41:18,700

2294
01:41:18,700 --> 01:41:20,520
కాబట్టి అని కనిపిస్తుంది ఏమి యొక్క ఉంటాము.

2295
01:41:20,520 --> 01:41:23,690
>> DynamoDB Streams ఉంటుంది
మేము లాంబ్డా కాల్ ఏమి ద్వారా ప్రాసెస్.

2296
01:41:23,690 --> 01:41:27,394
మేము ఈవెంట్ గురించి కొద్దిగా పేర్కొన్నారు
నడిచే అప్లికేషన్ ఆర్కిటెక్చర్లు.

2297
01:41:27,394 --> 01:41:28,810
లాంబ్డా ఆ కీలకాంశం.

2298
01:41:28,810 --> 01:41:32,840
లాంబ్డా డిమాండ్ పై భారత్ స్మృతి
ఒక ప్రత్యేక కార్యక్రమం ప్రతిస్పందనగా.

2299
01:41:32,840 --> 01:41:36,020
ఆ సంఘటనలను ఒకటి ఒక కావచ్చు
స్ట్రీమ్లో కనిపించే రికార్డు.

2300
01:41:36,020 --> 01:41:39,100
రికార్డు స్ట్రీమ్లో కనిపిస్తే,
మేము ఈ జావా ఫంక్షన్ పిలుస్తాను.

2301
01:41:39,100 --> 01:41:44,980
Well, ఈ JavaScript, మరియు లాంబ్డా ఉంది
Node.js, జావా, పైథాన్, మద్దతు

2302
01:41:44,980 --> 01:41:47,820
మరియు వెంటనే మద్దతు ఉంటుంది
ఇతర భాషలు అలాగే.

2303
01:41:47,820 --> 01:41:50,940
మరియు అది స్వచ్ఛమైన కోడ్ ఉంది, చెప్పటానికి తగినంత.

2304
01:41:50,940 --> 01:41:53,610
జావా లో వ్రాయండి, మీరు ఒక తరగతి వివరిస్తాయి.

2305
01:41:53,610 --> 01:41:55,690
మీరు లాంబ్డా లోకి JAR అప్ పుష్.

2306
01:41:55,690 --> 01:42:00,200
ఆపై మీరు తరగతి తెలుపుటకు
ఏ సంఘటన ప్రతిస్పందనగా కాల్.

2307
01:42:00,200 --> 01:42:04,770
ఆపై లాంబ్డా అవస్థాపన
ఆ వెనుక ఆ కోడ్ అమలు ఉంటుంది.

2308
01:42:04,770 --> 01:42:06,730
>> ఆ కోడ్ ప్రాసెస్ చేయవచ్చు
స్ట్రీమ్ ఆఫ్ రికార్డులు.

2309
01:42:06,730 --> 01:42:08,230
అది కోరుకుంటున్నారు ఏదైనా చేయవచ్చు.

2310
01:42:08,230 --> 01:42:11,650
ఈ ప్రత్యేక ఉదాహరణ, అన్ని మేము ఉన్నాము
నిజంగా గుణాలు లాగిన్ చేస్తున్న.

2311
01:42:11,650 --> 01:42:13,480
కానీ ఈ కేవలం కోడ్.

2312
01:42:13,480 --> 01:42:15,260
కోడ్ కుడి, ఏదైనా చేయవచ్చు?

2313
01:42:15,260 --> 01:42:16,600
>> కాబట్టి మీరు ఆ డేటా రొటేట్ చేయవచ్చు.

2314
01:42:16,600 --> 01:42:18,160
మీరు ఒక ఉత్పన్నం వీక్షణ సృష్టించవచ్చు.

2315
01:42:18,160 --> 01:42:21,160
అది ఒక పత్ర నిర్మాణాన్ని ఉంటే,
మీరు నిర్మాణం చదును చేయవచ్చు.

2316
01:42:21,160 --> 01:42:24,300
మీరు ప్రత్యామ్నాయ సూచికలు సృష్టించవచ్చు.

2317
01:42:24,300 --> 01:42:27,100
విషయాలు అన్ని రకాల మీరు
DynamoDB Streams తో.

2318
01:42:27,100 --> 01:42:28,780
>> మరియు నిజంగా, ఆ కనిపిస్తోంది ఏమిటి.

2319
01:42:28,780 --> 01:42:29,940
కాబట్టి మీరు ఆ నవీకరణలు వస్తున్న పొందండి.

2320
01:42:29,940 --> 01:42:31,190
వారు స్ట్రింగ్ వీచే చేస్తున్నారు.

2321
01:42:31,190 --> 01:42:32,720
వారు లాంబ్డా చర్య ద్వారా చదివి చేస్తున్నారు.

2322
01:42:32,720 --> 01:42:37,480
వారు డేటా తిరిగే చేస్తున్నపుడు
ఉత్పన్నం పట్టికలలో దానిని తీసుకుని వెళ్లడం,

2323
01:42:37,480 --> 01:42:42,200
మార్పు బాహ్య వ్యవస్థలు తెలియజేసే
మరియు ElastiCache డేటాను మోపడం.

2324
01:42:42,200 --> 01:42:45,900
>> మేము కాష్ ఉంచాలి ఎలా గురించి మాట్లాడారు
ఆ అమ్మకాలు డేటాబేస్ ముందు

2325
01:42:45,900 --> 01:42:46,450
దృష్టాంతంలో.

2326
01:42:46,450 --> 01:42:50,049
Well ఏమి జరిగితే నేను
అంశం వివరణ అప్డేట్?

2327
01:42:50,049 --> 01:42:52,340
Well, నేను కలిగి ఉంటే ఒక లాంబ్డా
ఫంక్షన్, ఆ పట్టిక నడుస్తున్న

2328
01:42:52,340 --> 01:42:55,490
నేను అంశం వివరణ అప్డేట్ ఉంటే, అది చేస్తాము
స్ట్రీమ్ ఆఫ్ రికార్డు ఎంచుకొని,

2329
01:42:55,490 --> 01:42:58,711
మరియు అది ElastiCache అప్డేట్ చేస్తాము
కొత్త డేటా సందర్భం.

2330
01:42:58,711 --> 01:43:00,460
కాబట్టి ఆ చాలా వార్తలు
మేము లాంబ్డా తో ఏమి.

2331
01:43:00,460 --> 01:43:02,619
ఇది కనెక్టర్లకు గ్లూ కోడ్ ఉంది.

2332
01:43:02,619 --> 01:43:04,410
మరియు అది నిజానికి ఇస్తుంది
ప్రయోగించే సామర్థ్యం

2333
01:43:04,410 --> 01:43:07,930
మరియు చాలా క్లిష్టమైన అనువర్తనాలను అమలు
ఒక ప్రత్యేక సర్వర్ లేకుండా

2334
01:43:07,930 --> 01:43:10,371
నిజంగా చల్లని ఉంది మౌలిక.

2335
01:43:10,371 --> 01:43:13,100
>> కాబట్టి యొక్క తిరిగి వెళ్ళి తెలపండి మా
వాస్తవ కాల ఓటింగ్ నిర్మాణం.

2336
01:43:13,100 --> 01:43:17,984
ఈ కొత్త మరియు మెరుగైన మా
ప్రవాహాలు మరియు KCL అప్లికేషన్ ఎనేబుల్.

2337
01:43:17,984 --> 01:43:20,150
అదే, మేము ముందు
ఎన్నికల ఏ స్థాయిలో నిర్వహించడానికి.

2338
01:43:20,150 --> 01:43:21,100
మేము దీన్ని ఇష్టపడుతున్నారు.

2339
01:43:21,100 --> 01:43:24,770
మేము స్కాటర్ చుంగులు బయటకు చేస్తున్నా
బహుళ బకెట్లు అంతటా.

2340
01:43:24,770 --> 01:43:26,780
మదుపర్లు లాకింగ్ జరగబోతోంది పొందారు.

2341
01:43:26,780 --> 01:43:30,192
మేము మా ఓటర్లు ఉంచుకోవచ్చు
వారి ఓట్లు మార్చకుండా.

2342
01:43:30,192 --> 01:43:31,400
వారు మాత్రమే మాత్రమే ఒకసారి ఓటు చేయవచ్చు.

2343
01:43:31,400 --> 01:43:32,880
ఈ అద్భుతమైన ఉంది.

2344
01:43:32,880 --> 01:43:35,895
రియల్ టైమ్ తప్పు సహనం,
ఇప్పుడు కొలవలేని అగ్రిగేషన్.

2345
01:43:35,895 --> 01:43:38,270
విషయం మీద పడిపోతే, అది
కూడా పునఃప్రారంభించవలసి పేరు తెలిసిన

2346
01:43:38,270 --> 01:43:41,300
ఇది ఎందుకంటే తిరిగి వచ్చినప్పుడు
మేము KCL అనువర్తనాన్ని ఉపయోగించి చేస్తున్నారు.

2347
01:43:41,300 --> 01:43:45,700
మరియు తర్వాత మేము కూడా ఉపయోగించవచ్చు
KCL అప్లికేషన్ డేటా పుష్

2348
01:43:45,700 --> 01:43:48,820
ఇతర కోసం రెడ్ షిఫ్ట్ కు
అనువర్తనం విశ్లేషణలు, లేదా ఉపయోగం

2349
01:43:48,820 --> 01:43:51,990
ఎలాస్టిక్ మ్యార్రెడ్యూస్చే అమలు
ఆఫ్ వాస్తవ కాల స్ట్రీమింగ్ aggregations

2350
01:43:51,990 --> 01:43:53,180
డేటా.

2351
01:43:53,180 --> 01:43:55,480
>> కాబట్టి ఈ విషయాలు మనం
చాలా గురించి మాట్లాడారు లేదు.

2352
01:43:55,480 --> 01:43:57,375
కానీ వారు అదనపు ఉన్నాము
వచ్చిన సాంకేతికతలతో

2353
01:43:57,375 --> 01:44:00,310
మీరు చూస్తున్న సమయంలో భరించలేక
దృష్టాంతాల రకాల వద్ద.

2354
01:44:00,310 --> 01:44:03,160
>> అన్ని కుడి, దాని గురించి కాబట్టి
DynamoDB ప్రవాహాలు విశ్లేషణలు.

2355
01:44:03,160 --> 01:44:05,340
మీరు de-మోసగించు తీసుకోవచ్చు
డేటా, అన్ని రకాల

2356
01:44:05,340 --> 01:44:09,490
nice విషయం యొక్క, సగటు సమాచారం లో
జ్ఞాపకశక్తి, ఆ ఉత్పన్న పట్టికలు సృష్టించడానికి.

2357
01:44:09,490 --> 01:44:13,110
ఆ భారీ ఉపయోగం కేస్
వినియోగదారులు చాలా

2358
01:44:13,110 --> 01:44:16,950
సమూహ తీసుకొని, పాలుపంచుకుంటారు
ఆ JSON పత్రాలు యొక్క లక్షణాలు

2359
01:44:16,950 --> 01:44:18,946
మరియు అదనపు సూచికలు సృష్టించడం.

2360
01:44:18,946 --> 01:44:21,680

2361
01:44:21,680 --> 01:44:23,150
>> మేము చివరిలో ఉన్నారు.

2362
01:44:23,150 --> 01:44:26,689
నాతో కనే ధన్యవాదాలు.

2363
01:44:26,689 --> 01:44:28,480
కాబట్టి యొక్క మాట్లాడటానికి వీలు
సూచన నిర్మాణం.

2364
01:44:28,480 --> 01:44:33,440
DynamoDB కాబట్టి మధ్యలో కూర్చుని
AWS అవస్థాపన చాలా.

2365
01:44:33,440 --> 01:44:37,090
సాధారణంగా మీరు హుక్ చేయవచ్చు
ఏదైనా వరకు మీకు కావలసిన.

2366
01:44:37,090 --> 01:44:45,600
అప్లికేషన్స్ డైనమో ఉన్నాయి ఉపయోగించి నిర్మించబడింది
లాంబ్డా, ElastiCache, CloudSearch,

2367
01:44:45,600 --> 01:44:49,890
ఎలాస్టిక్ లోకి బయటకు డేటా పుష్
మ్యార్రెడ్యూస్చే, DynamoDB నుండి దిగుమతి ఎగుమతి

2368
01:44:49,890 --> 01:44:52,370
ఎస్ 3, పనులకూ అన్ని రకాల లోకి.

2369
01:44:52,370 --> 01:44:54,120
కానీ బహుశా ఉత్తమ
గురించి మాట్లాడటానికి విషయం

2370
01:44:54,120 --> 01:44:56,119
మరియు ఈ నిజంగా ఏమి ఉంది
ఆసక్తికరమైన ఉన్నప్పుడు మనం

2371
01:44:56,119 --> 01:44:58,350
ఈవెంట్ నడిచే అప్లికేషన్లు గురించి మాట్లాడటానికి.

2372
01:44:58,350 --> 01:45:00,300
>> ఈ ఒక ఉదాహరణ
ఒక అంతర్గత ప్రాజెక్ట్ను

2373
01:45:00,300 --> 01:45:04,850
మేము నిజంగా ఎక్కడ కలిగి
ప్రచురణ సర్వే ఫలితాలు సేకరించడానికి.

2374
01:45:04,850 --> 01:45:07,700
ఒక ఇమెయిల్ లింక్ లో కాబట్టి ఆ
మేము అక్కడ ఉంటాం, పంపించండి

2375
01:45:07,700 --> 01:45:11,350
ఒక కొద్దిగా లింక్ మాట్లాడుతూ క్లిక్ ఉంటుంది
ఇక్కడ సర్వే స్పందించడం.

2376
01:45:11,350 --> 01:45:14,070
మరియు ఒక వ్యక్తి క్లిక్
ఆ లింక్, ఏమి జరుగుతుంది

2377
01:45:14,070 --> 01:45:18,020
వారు ఒక సురక్షిత లాగేందుకు ఉంది
S3 నుండి HTML సర్వే రూపం.

2378
01:45:18,020 --> 01:45:18,980
ఏ సర్వర్ ఉంది.

2379
01:45:18,980 --> 01:45:20,600
ఈ కేవలం ఒక S3 వస్తువు.

2380
01:45:20,600 --> 01:45:22,770
>> ఆ రూపం వస్తుంది
బ్రౌజర్ లో లోడుచేస్తుంది.

2381
01:45:22,770 --> 01:45:24,240
ఇది వెన్నెముక కలిగియున్నారు.

2382
01:45:24,240 --> 01:45:30,160
ఇది క్లిష్టమైన జావాస్క్రిప్ట్ సంపాదించి
అది అమలు.

2383
01:45:30,160 --> 01:45:33,557
కనుక ఇది చాలా రిచ్ అప్లికేషన్ వార్తలు
క్లయింట్ యొక్క బ్రౌజర్ లో అమలవుతున్నాయి.

2384
01:45:33,557 --> 01:45:36,390
వారు కాదు అని తెలియదు
బ్యాక్ ఎండ్ సర్వర్ సంభాషిస్తుంది.

2385
01:45:36,390 --> 01:45:38,220
ఈ సమయంలో, అది అన్ని బ్రౌజర్.

2386
01:45:38,220 --> 01:45:41,780
>> వారు ఫలితాలు ప్రచురించడానికి
మేము అమెజాన్ API గేట్వే కాల్.

2387
01:45:41,780 --> 01:45:46,270
API గేట్వే కేవలం ఒక వెబ్ API ఉంది
మీరు నిర్వచించే మరియు జంటగా చేసే

2388
01:45:46,270 --> 01:45:47,760
సంసార మీకు కావలసిన.

2389
01:45:47,760 --> 01:45:50,990
ఈ ప్రత్యేక సందర్భంలో, మేము ఉన్నాము
ఒక లాంబ్డా ఫంక్షన్ వరకు కట్టిపడేశాయి.

2390
01:45:50,990 --> 01:45:54,797
>> కాబట్టి నా పోస్ట్ ఆపరేషన్ ఉంది
ఏ సర్వర్ తో జరుగుతున్న.

2391
01:45:54,797 --> 01:45:56,380
సాధారణంగా ఆ API గేట్వే అక్కడ కూర్చుని.

2392
01:45:56,380 --> 01:45:58,770
ఇది నాకు ప్రజలు వరకు ఏమీ ఖర్చవుతుంది
కుడి, దానికి పంపించవచ్చు ప్రారంభం?

2393
01:45:58,770 --> 01:46:00,269
లాంబ్డా ఫంక్షన్ అక్కడే కూర్చుని.

2394
01:46:00,269 --> 01:46:03,760
మరియు అది వరకు నాకు ఏమీ ఖర్చు
ప్రజలు ఇది కొట్టడం మొదలు.

2395
01:46:03,760 --> 01:46:07,270
కాబట్టి మీరు వాల్యూమ్ వలె, చూడగలరు
ఆరోపణలు వచ్చినప్పుడు పెరుగుతుంది, ఆ.

2396
01:46:07,270 --> 01:46:09,390
నేను ఒక సర్వర్ 7/24 నడుస్తున్న లేదు చేస్తున్నాను.

2397
01:46:09,390 --> 01:46:12,310
>> నేను రూపం లాగండి
డౌన్ బకెట్ నుండి,

2398
01:46:12,310 --> 01:46:15,719
మరియు నేను API ద్వారా పోస్ట్
లాంబ్డా ఫంక్షన్ గేట్వే.

2399
01:46:15,719 --> 01:46:17,510
ఆపై లాంబ్డా
ఫంక్షన్ మీకు తెలిసిన, చెప్పారు

2400
01:46:17,510 --> 01:46:20,600
ఏమి, నేను కొన్ని PIIs పొందారు, కొన్ని
వ్యక్తిగతంగా గుర్తించదగిన సమాచారాన్ని

2401
01:46:20,600 --> 01:46:21,480
ఈ ప్రతిస్పందనలు.

2402
01:46:21,480 --> 01:46:23,020
నేను వినియోగదారులు నుండి వస్తున్న వ్యాఖ్యలు వచ్చింది.

2403
01:46:23,020 --> 01:46:24,230
నేను ఇమెయిల్ చిరునామాలను పొందారు.

2404
01:46:24,230 --> 01:46:26,190
నేను యూజర్ పేర్లు పొందారు.

2405
01:46:26,190 --> 01:46:27,810
>> నాకు ఈ వేరుపడ్డాయి లెట్.

2406
01:46:27,810 --> 01:46:30,280
నేను కొన్ని ఉత్పత్తి వెళుతున్న
ఈ రికార్డ్ ఆఫ్ మెటాడేటా.

2407
01:46:30,280 --> 01:46:32,850
నేను పుష్ వెళుతున్న
DynamoDB లోకి మెటాడేటా.

2408
01:46:32,850 --> 01:46:36,059
మరియు నేను అన్ని డేటా గుప్తీకరించడానికి కాలేదు
నేను కావాలా మరియు DynamoDB గా పుష్.

2409
01:46:36,059 --> 01:46:38,600
కానీ ఈ, నాకు సులభం
ముందుకు ఒక సే వెళ్ళడానికి, సందర్భంలో ఉపయోగించడానికి,

2410
01:46:38,600 --> 01:46:42,800
నేను ముడి డేటా పుష్ వెళుతున్న
ఎన్క్రిప్టెడ్ ఎస్ 3 బకెట్ లోకి.

2411
01:46:42,800 --> 01:46:47,240
నేను S3 సర్వర్ వైపు నిర్మించారు ఉపయోగించడానికి
ఎన్క్రిప్షన్ మరియు అమెజాన్ యొక్క కీ మానేజ్మెంట్

2412
01:46:47,240 --> 01:46:51,600
తద్వారా సర్వీస్ నేను ఒక కీ కలిగి
ఒక సాధారణ విరామం రొటేట్ చేయవచ్చు,

2413
01:46:51,600 --> 01:46:55,010
మరియు నేను ఆ PII డేటా కాపాడుతుంది
ఈ మొత్తం వర్క్ఫ్లో భాగంగా.

2414
01:46:55,010 --> 01:46:55,870
>> నేను ఏమి చేసారు?

2415
01:46:55,870 --> 01:47:00,397
నేను కేవలం ఒక మొత్తం మోహరించిన చేసిన
అప్లికేషన్, మరియు నేను ఏ సర్వర్ కలిగి.

2416
01:47:00,397 --> 01:47:02,980
కాబట్టి ఈవెంట్ అప్లికేషన్ నడిచే ఏమిటి
నిర్మాణం మీరు కోసం చేస్తుంది.

2417
01:47:02,980 --> 01:47:05,730
>> ఇప్పుడు మీరు అనుకుంటే
దీన్ని కోసం ఉపయోగించడానికి కేసు

2418
01:47:05,730 --> 01:47:08,730
మేము నేను మాట్లాడటం చేస్తున్నాను ఇతర వినియోగదారులు కలిగి
గురించి ఈ ఖచ్చితమైన ఆర్కిటెక్చర్కు ఎవరు

2419
01:47:08,730 --> 01:47:14,560
గోచరమయ్యే పెద్ద పోరాటాలు, నడిపే
ఈ చూడటం మరియు నా ఓహ్, వెళ్తున్నారు.

2420
01:47:14,560 --> 01:47:17,840
ఇప్పుడు, వారు ఎందుకంటే
ప్రధానంగా దాన్ని పుష్,

2421
01:47:17,840 --> 01:47:21,900
కేవలం కూర్చుని ప్రచారం వీలు
అది అక్కడ బాబు, మరియు వరకు

2422
01:47:21,900 --> 01:47:24,400
గురించి ఒక అత్తి ఆందోళన
అవస్థాపన ఏ రకమైన

2423
01:47:24,400 --> 01:47:26,120
ఇది మద్దతు అక్కడ ఉండాలి అన్నారు.

2424
01:47:26,120 --> 01:47:28,600
ఆపై వెంటనే
ఆ ప్రచారం జరుగుతుంది

2425
01:47:28,600 --> 01:47:31,520
అది మౌలిక సదుపాయాలకు వంటిది
కేవలం వెంటనే వెళ్ళిపోతుంది

2426
01:47:31,520 --> 01:47:33,680
నిజంగా అక్కడ ఎందుకంటే
ఏ అవస్థాపన.

2427
01:47:33,680 --> 01:47:35,660
ఇది లాంబ్డా వర్గంపై కేవలం కోడ్ ఉంది.

2428
01:47:35,660 --> 01:47:38,560
ఇది DynamoDB ఉండే డేటా ఉంది.

2429
01:47:38,560 --> 01:47:41,340
ఇది ఒక అద్భుతమైన మార్గం
అప్లికేషన్లు నిర్మించడానికి.

2430
01:47:41,340 --> 01:47:43,970
>> ప్రేక్షకులు: సో మరింత అది
అశాశ్వత దాని మామూలు పరిస్థితి కంటే

2431
01:47:43,970 --> 01:47:45,740
అది అసలైన సర్వర్లో నిల్వ ఉంటే?

2432
01:47:45,740 --> 01:47:46,823
>> రిక్ HOULIHAN: ఖచ్చితంగా.

2433
01:47:46,823 --> 01:47:49,190
సర్వర్ ఉదాహరణకు ఎందుకంటే
ఒక 7/24 అవవచ్చు.

2434
01:47:49,190 --> 01:47:51,954
ఇది అందుబాటులో ఉండాలి
ఎవరైనా స్పందించడం.

2435
01:47:51,954 --> 01:47:52,620
Well ఏమి అంచనా?

2436
01:47:52,620 --> 01:47:55,410
S3 7/24 అందుబాటులో ఉంది.

2437
01:47:55,410 --> 01:47:57,100
S3 ఎల్లప్పుడూ స్పందిస్తుంది.

2438
01:47:57,100 --> 01:47:59,320
మరియు S3 చాలా, చాలా మంచి ఉంది
వస్తువులు అల్లడం వద్ద.

2439
01:47:59,320 --> 01:48:02,590
ఆ వస్తువుల HTML ఫైళ్ళను, లేదా
జావాస్క్రిప్ట్ ఫైళ్లు, లేదా మీకు కావలసిన.

2440
01:48:02,590 --> 01:48:07,430
మీరు చాలా రిచ్ వెబ్ అప్లికేషన్లను కూడా రన్ చేయగలుగుతుంది
S3 బకెట్లు అవ్ట్, మరియు ప్రజలు ఏమి.

2441
01:48:07,430 --> 01:48:10,160
>> కాబట్టి ఆ ఆలోచన ఇక్కడ వార్తలు
విధంగా దూరంగా నుండి పొందుటకు ఉంది

2442
01:48:10,160 --> 01:48:11,270
మేము దాని గురించి ఆలోచించటం ఉపయోగిస్తారు.

2443
01:48:11,270 --> 01:48:14,270
మేము అన్ని లో అనుకుంటున్నాను ఉపయోగిస్తారు
సర్వర్లు మరియు ఆతిథ్య యొక్క నిబంధనలు.

2444
01:48:14,270 --> 01:48:16,580
ఇది ఇకపై ఆ గురించి కాదు.

2445
01:48:16,580 --> 01:48:19,310
ఇది కోడ్ వంటి వౌలిక గురించి.

2446
01:48:19,310 --> 01:48:22,470
క్లౌడ్ కోడ్ విస్తరించడానికి మరియు
క్లౌడ్ మీరు దానిని అమలు అనుమతిస్తాయి.

2447
01:48:22,470 --> 01:48:24,980
మరియు ఆ AWS చేయాలని ప్రయత్నిస్తున్నారు ఏమిటి.

2448
01:48:24,980 --> 01:48:29,690
>> ప్రేక్షకులు: మధ్యలో మీ బంగారు బాక్స్ కాబట్టి
API గేట్వే ఆఫ్, సర్వర్ వలె లేదు

2449
01:48:29,690 --> 01:48:30,576
కానీ బదులుగా కేవలం ఉంది

2450
01:48:30,576 --> 01:48:32,850
>> రిక్ HOULIHAN: మీరు ఆలోచించవచ్చు
సర్వర్ ముఖభాగాన్ని గా.

2451
01:48:32,850 --> 01:48:38,040
ఇది అన్ని అది ఒక HTTP తీసుకొని వెళ్తాము ఉంది
అభ్యర్థించవచ్చు మరియు మరొక ప్రక్రియ మ్యాప్.

2452
01:48:38,040 --> 01:48:39,192
ఆ అది అంతే.

2453
01:48:39,192 --> 01:48:41,525
మరియు ఈ సందర్భంలో, మనం మ్యాపింగ్ చేస్తున్నారు
అది ఒక లాంబ్డా ఫంక్షన్.

2454
01:48:41,525 --> 01:48:44,119

2455
01:48:44,119 --> 01:48:45,410
All right, కాబట్టి నేను వచ్చింది అంతే.

2456
01:48:45,410 --> 01:48:46,190
చాలా ధన్యవాదాలు.

2457
01:48:46,190 --> 01:48:46,800
నేను దాన్ని మెచ్చుకుంటున్నాను.

2458
01:48:46,800 --> 01:48:48,100
మనం కాలక్రమంలో కొద్దిగా కావలసిన తెలుసు.

2459
01:48:48,100 --> 01:48:49,980
మరియు ఆశాజనక మీరు guys వచ్చింది
సమాచారం యొక్క ఒక చిన్న బిట్

2460
01:48:49,980 --> 01:48:51,410
మీరు నేడు దూరంగా పట్టవచ్చు.

2461
01:48:51,410 --> 01:48:53,520
నేను వెళ్లి మరియు నేను క్షమాపణ
మీ తలలు కొన్ని,

2462
01:48:53,520 --> 01:48:56,697
కానీ ఒక మంచి చాలా ఉంది
ప్రాథమిక పునాది జ్ఞానం

2463
01:48:56,697 --> 01:48:58,280
నేను మీరు చాలా విలువైనది.

2464
01:48:58,280 --> 01:48:59,825
కాబట్టి నాకు కలిగి ధన్యవాదాలు.

2465
01:48:59,825 --> 01:49:00,325
[అప్లాజ్]

2466
01:49:00,325 --> 01:49:02,619
ప్రేక్షకులు: [వినబడని]
మీరు చెప్పడం జరిగింది చేస్తే ఉంది

2467
01:49:02,619 --> 01:49:05,160
మీరు విషయం ద్వారా వెళ్ళడానికి కలిగి
ప్రారంభం నుండి ముగింపు

2468
01:49:05,160 --> 01:49:07,619
కుడి విలువలు పొందడానికి
లేదా అదే విలువలు,

2469
01:49:07,619 --> 01:49:09,410
ఎలా చేస్తాను విలువలు
[వినబడని] ఉంటే మార్చడానికి.

2470
01:49:09,410 --> 01:49:10,480
>> రిక్ HOULIHAN: ఓహ్, మార్పురహిత విధానం కావల్సిన?

2471
01:49:10,480 --> 01:49:11,800
విలువలు ఎలా మారుస్తామని?

2472
01:49:11,800 --> 01:49:15,180
Well, ఎందుకంటే నేను అమలు కాలేదు ఉంటే
అది చివర అన్ని మార్గం,

2473
01:49:15,180 --> 01:49:19,770
అప్పుడు నేను ఏమి మార్పులు తెలియదు
చివరి మైలు చేశారు.

2474
01:49:19,770 --> 01:49:22,144
అది చేస్తాడు కాదు
నేను చూసిన అదే డేటా.

2475
01:49:22,144 --> 01:49:24,560
ప్రేక్షకులు: ఓహ్, మీరు కేవలం
మొత్తం ఇన్పుట్ సంపాదించిన లేదు.

2476
01:49:24,560 --> 01:49:24,770
రిక్ HOULIHAN: కుడి.

2477
01:49:24,770 --> 01:49:26,895
మీరు మొదలు నుండి వెళ్ళాలి
చివర, మరియు అప్పుడు అది వార్తలు

2478
01:49:26,895 --> 01:49:29,280
ఒక స్థిరమైన స్థితిలో ఉన్నట్లు జరగబోతోంది.

2479
01:49:29,280 --> 01:49:31,520
కూల్.

2480
01:49:31,520 --> 01:49:35,907
>> ప్రేక్షకులు: మీరు మాకు చూపించింది కాబట్టి DynamoDB
పత్రం లేదా కీ విలువ చేయవచ్చు.

2481
01:49:35,907 --> 01:49:38,740
మరియు మేము సమయం గడిపేవాడు
ఒక హాష్ మరియు మార్గాలు కీ విలువ

2482
01:49:38,740 --> 01:49:40,005
దాని చుట్టూ కుదుపు.

2483
01:49:40,005 --> 01:49:43,255
మీరు ఆ పట్టికలు వద్ద చూచినప్పుడు, ఆ
పత్రం విధానం విడిచిపెట్టి?

2484
01:49:43,255 --> 01:49:44,600
>> రిక్ HOULIHAN: నేను కాదు
దాని వెనుక వదిలి చెప్పటానికి.

2485
01:49:44,600 --> 01:49:45,855
>> ప్రేక్షకులు: వారు ఉన్నారు నుండి వేరు

2486
01:49:45,855 --> 01:49:49,140
>> రిక్ HOULIHAN: పత్రంతో
విధానం, DynamoDB లో డాక్యుమెంట్ రకము

2487
01:49:49,140 --> 01:49:50,880
కేవలం మరొక లక్షణం భావిస్తున్నది ఉంది.

2488
01:49:50,880 --> 01:49:53,560
ఇది కలిగి ఒక లక్షణం
ఒక క్రమానుగత డేటా నిర్మాణం.

2489
01:49:53,560 --> 01:49:56,980
ఆపై ప్రశ్నల్లో,
మీరు లక్షణాలు ఉపయోగించవచ్చు

2490
01:49:56,980 --> 01:49:59,480
ఆబ్జెక్ట్ నొటేషన్ ఉపయోగించి ఆ వస్తువుల.

2491
01:49:59,480 --> 01:50:03,562
నేను ఒక సమూహ మీద ఫిల్టర్ చెయ్యవచ్చు
JSON పత్రం యొక్క ఆస్తి.

2492
01:50:03,562 --> 01:50:05,520
ప్రేక్షకులు: సో ఏ సమయంలో నేను
ఒక పత్రం విధానం చేయండి,

2493
01:50:05,520 --> 01:50:07,906
నేను విధమైన tabular-- వద్దకు చేయవచ్చు

2494
01:50:07,906 --> 01:50:08,780
ప్రేక్షకులు: ఖచ్చితంగా.

2495
01:50:08,780 --> 01:50:09,800
ప్రేక్షకులు: --indexes మరియు
మీరు కేవలం గురించి మాట్లాడారు విషయాలు.

2496
01:50:09,800 --> 01:50:11,280
రిక్ HOULIHAN: అవును,
సూచికలు మరియు అన్ని ఆ,

2497
01:50:11,280 --> 01:50:13,363
ఉన్నప్పుడు మీరు ఇండెక్స్ కావలసిన
JSON యొక్క లక్షణాలు,

2498
01:50:13,363 --> 01:50:18,230
మేము అలా భావిస్తాను ఆ విధంగా ఉంటే
మీరు ఒక JSON వస్తువు లేదా ఒక పత్రం ఇన్సర్ట్

2499
01:50:18,230 --> 01:50:20,780
డైనమో లోకి, మీరు ప్రవాహాలు వుపయోగించాలి.

2500
01:50:20,780 --> 01:50:22,400
Streams ఇన్పుట్ చదివి ఉంటుంది.

2501
01:50:22,400 --> 01:50:24,340
మీరు JSON ఆ పొంది
అభ్యంతరం మరియు మీరు OK చెప్పాను,

2502
01:50:24,340 --> 01:50:26,030
నేను ఇండెక్స్ కావలసిన ఆస్తి ఏమిటి?

2503
01:50:26,030 --> 01:50:28,717
>> మీరు ఒక ఉత్పన్నం పట్టిక సృష్టించడానికి.

2504
01:50:28,717 --> 01:50:30,300
ఇప్పుడు అది ప్రస్తుతం పని మార్గం.

2505
01:50:30,300 --> 01:50:32,650
మేము ఇండెక్స్ మిమ్మల్ని అనుమతిస్తుంది లేదు
నేరుగా ఆ లక్షణాలు.

2506
01:50:32,650 --> 01:50:33,520
>> ప్రేక్షకులు: మీ పత్రాలు Tabularizing.

2507
01:50:33,520 --> 01:50:36,230
>> రిక్ HOULIHAN: సరిగ్గా, చదునుగా
అది, సరిగ్గా, అది tabularizing.

2508
01:50:36,230 --> 01:50:37,415
అది మీరు తో ఏమి ఉంది.

2509
01:50:37,415 --> 01:50:37,860
>> ప్రేక్షకులు: ధన్యవాదాలు.

2510
01:50:37,860 --> 01:50:39,609
>> రిక్ HOULIHAN: YEP,
ఖచ్చితంగా, ధన్యవాదాలు.

2511
01:50:39,609 --> 01:50:42,240
ప్రేక్షకులు: సో ఇది ఒక రకంగా
మొంగో Redis classifers కలుస్తుంది.

2512
01:50:42,240 --> 01:50:43,990
>> రిక్ HOULIHAN: అవును,
ఆ వంటి చాలా ఉంది.

2513
01:50:43,990 --> 01:50:45,940
అది ఒక మంచి వివరణ ఉంది.

2514
01:50:45,940 --> 01:50:47,490
కూల్.

2515
01:50:47,490 --> 01:50:49,102