1
00:00:00,000 --> 00:00:05,042
>> [સંગીત વગાડવાનો]

2
00:00:05,042 --> 00:00:06,000
ડેવીડના MALAN: બધા અધિકાર.

3
00:00:06,000 --> 00:00:07,630
આવતા માટે ખૂબ આભાર.

4
00:00:07,630 --> 00:00:11,850
આ Docker, એક પર CS50 પરિસંવાદ છે
ટેકનોલોજી જાતને અને CS50 અમે તે

5
00:00:11,850 --> 00:00:13,392
હવે થોડા સમય માટે ઉપયોગ કરવાનું શરૂ કર્યું છે.

6
00:00:13,392 --> 00:00:15,766
તેથી મારા નામ ડેવિડ Malan હું છે
હાર્વર્ડ પરિચય શીખવે

7
00:00:15,766 --> 00:00:16,671
કમ્પ્યુટર સાયન્સ.

8
00:00:16,671 --> 00:00:18,670
અમુક વર્ષો સુધી,
અમે વિદ્યાર્થીઓ આપીને કરવામાં આવ્યા છે

9
00:00:18,670 --> 00:00:20,435
ડાઉનલોડ ક્લાઈન્ટ બાજુ
વર્ચ્યુઅલ મશીનો

10
00:00:20,435 --> 00:00:22,134
જેના પર તેઓ તેમની સમસ્યાઓ સેટ કરવું.

11
00:00:22,134 --> 00:00:24,300
આપણે હવે સંક્રમિત છે કે
એક મેઘ પર્યાવરણ માટે

12
00:00:24,300 --> 00:00:27,396
કે ખરેખર આ ટેકનોલોજીનો ઉપયોગ
જેમ કે, Docker કહેવાય તમામ CS50 કે

13
00:00:27,396 --> 00:00:29,270
વિદ્યાર્થીઓ હવે તેમના
પોતાના Docker કન્ટેનર

14
00:00:29,270 --> 00:00:31,180
તમે તરત વિશે બધા સાંભળવા મળશે છે.

15
00:00:31,180 --> 00:00:33,740
>> વધુમાં, CS50 સર્વર પર
ઘણા વર્ષો માટે બાજુ ક્લસ્ટર,

16
00:00:33,740 --> 00:00:35,290
અમે એમેઝોન વાદળ સર્વર ઉપયોગ કરતા હતા.

17
00:00:35,290 --> 00:00:37,164
અમે વ્યક્તિગત ચાલી હતી
વર્ચ્યુઅલ મશીનો.

18
00:00:37,164 --> 00:00:40,330
તે પણ, અમે સંક્રમણ શરૂ કર્યું
Docker કન્ટેનર કહેવાય આ વસ્તુઓ

19
00:00:40,330 --> 00:00:43,762
તેથી અમારા કાર્યક્રમો બધા હવે છે કે
સંપૂર્ણપણે એક બીજા અલગ.

20
00:00:43,762 --> 00:00:46,720
તે માટે અને વધુ છે, તેથી મને પરવાનગી આપે છે
અમારા મિત્રો, નિકો અને Mano દાખલ

21
00:00:46,720 --> 00:00:48,574
Docker જાતે.

22
00:00:48,574 --> 00:00:49,740
નિકોલા KaBar: આભાર, ડેવિડ.

23
00:00:49,740 --> 00:00:51,410
કેમ છો બધા.

24
00:00:51,410 --> 00:00:54,230
મારું નામ નિકો છે અને આ Mano છે.

25
00:00:54,230 --> 00:00:58,260
અમે Docker છો.

26
00:00:58,260 --> 00:01:02,240
અમે about-- વાત કરી રહ્યા છીએ
Docker ગાય્ઝ તમે એક પ્રસ્તાવના આપ્યા,

27
00:01:02,240 --> 00:01:08,100
અને આસ્થાપૂર્વક, અંત તરફ
આ ચર્ચા તમે ખ્યાલ કરી શકો છો

28
00:01:08,100 --> 00:01:12,890
તમે ડૉક્ટર ઉપયોગ કરી શકો છો કેટલી
તમારી અરજી વિકાસ ઓક્ઝાલેટ

29
00:01:12,890 --> 00:01:14,200
અને જમાવટ.

30
00:01:14,200 --> 00:01:21,250
>> તેથી, અમે વાસ્તવિક બંધ શરૂ જઈ રહ્યાં છો
કેટલાક પૃષ્ઠભૂમિ માહિતી સાથે ઝડપી.

31
00:01:21,250 --> 00:01:22,750
Docker બધા વિશે છે તે વર્ણવો.

32
00:01:22,750 --> 00:01:25,490
તે કેવી રીતે કામ કરે છે?

33
00:01:25,490 --> 00:01:27,400
તે કેવી રીતે architected છે?

34
00:01:27,400 --> 00:01:29,360
હું કેટલાક જનતા કરવાનું આવશે.

35
00:01:29,360 --> 00:01:35,070
અને Mano હોઈ ચાલે છે
વર્ણન તમે Docker ઉપયોગ કરી શકો છો કેવી રીતે

36
00:01:35,070 --> 00:01:37,720
અને તમે ચોક્કસ પગલાંઓ આપ્યા
તમે શરૂ કરી શકો છો કેવી રીતે.

37
00:01:37,720 --> 00:01:41,490
>> તમે ગાય્ઝ પકડી શકે છે, તો હું કદર કરશે
અંત તરફ તમારા પ્રશ્નો માટે બંધ.

38
00:01:41,490 --> 00:01:46,800
આ રીતે, હું તે સંબોધન કરી શકે છે
પ્રસ્તુતિ દરમિયાન પ્રશ્નો.

39
00:01:46,800 --> 00:01:52,150
તેથી અમે કેટલાક સમય છોડી જાય છે
પ્રશ્નો માટે અંત તરફ.

40
00:01:52,150 --> 00:01:55,170
>> જે છે, ઝડપી તેથી માત્ર વાસ્તવિક
ખરેખર ક્યારેય Docker પર કામ કર્યું હતું,

41
00:01:55,170 --> 00:01:56,850
તેની સાથે રમી જેવું?

42
00:01:56,850 --> 00:01:58,000
ઓસમ.

43
00:01:58,000 --> 00:01:58,520
કૂલ.

44
00:01:58,520 --> 00:01:59,817
ગ્રેટ.

45
00:01:59,817 --> 00:02:01,525
તેથી, હું શરૂ કરવા જઇ રહ્યો છું
કેટલાક ઇતિહાસ છે.

46
00:02:01,525 --> 00:02:04,350

47
00:02:04,350 --> 00:02:09,820
તેથી પાછા '90s અને
મૂળભૂત 2000 ના પ્રારંભમાં,

48
00:02:09,820 --> 00:02:16,940
વેબ વિકાસકર્તાઓ, એપ્લિકેશન વિકાસકર્તાઓ તરીકે,
તેઓ એક અરજી જમાવવા માટે ગયા ત્યારે

49
00:02:16,940 --> 00:02:19,350
તે મેટલ ખુલ્લી જોડાયેલું હતું.

50
00:02:19,350 --> 00:02:20,860
તે એક સર્વર હતી.

51
00:02:20,860 --> 00:02:22,870
તે એક એપ્લિકેશન હતી.

52
00:02:22,870 --> 00:02:25,260
>> પરંપરાગત રીતે, એક ઉદાહરણ
એક દીવો સ્ટેક જેવા હશે,

53
00:02:25,260 --> 00:02:30,630
તમે ખરેખર હતી જ્યાં
સાધનો પૂલ લાવે છે.

54
00:02:30,630 --> 00:02:37,110
સીપીયુ, મેમરી, ડિસ્ક, નેટવર્ક સ્થાપિત
કે ટોચ પર ઓપરેટિંગ સિસ્ટમ.

55
00:02:37,110 --> 00:02:40,060
તમે કંઈક આપતા રહ્યાં છો, તો જો
તમે ખરેખર વેબ સર્વર આવી રહી છે

56
00:02:40,060 --> 00:02:42,470
તમે કંઈક જરૂર
અપાચે તે સેવા આપવા માટે.

57
00:02:42,470 --> 00:02:47,540
>> તમારી અરજી તો
, ડેટાબેઝ, બેકહેન્ડ જરૂર

58
00:02:47,540 --> 00:02:50,840
તમે કંઈક સ્થાપિત કરશે
MySQL જેવા છે, અને તેથી પર.

59
00:02:50,840 --> 00:02:55,910
અને તમે રન સમય જરૂર હોય તો, PHPs
અને PHP, Python કામ હતા.

60
00:02:55,910 --> 00:02:59,480
અને તેથી અમે ખરેખર હતી
ક્રમમાં તે પગલાં લેવા

61
00:02:59,480 --> 00:03:02,060
તમારી અરજી ઉપર અને ચાલતું વિચાર.

62
00:03:02,060 --> 00:03:08,440
>> તમે વધુ Compute શક્તિ જરૂરી હોય તો, તમે
મૂળભૂત રીતે તમારા ઓપ્સ વ્યક્તિ કહી હતી

63
00:03:08,440 --> 00:03:16,260
અથવા ગેલન જાઓ અને એક નવી વધારતી
હાર્ડવેર ભાગ છે, તે સાથે જોડાવા માટે,

64
00:03:16,260 --> 00:03:19,850
અને તમે તે પુનરાવર્તન છે
પ્રક્રિયાઓ ફરીથી અને ફરીથી.

65
00:03:19,850 --> 00:03:23,680
તેથી આ પ્રક્રિયા હતી
પ્રમાણમાં ખર્ચાળ.

66
00:03:23,680 --> 00:03:26,080
ચોક્કસપણે ખૂબ જ ધીમી હતી.

67
00:03:26,080 --> 00:03:27,550
>> તે બિનકાર્યક્ષમ હતી.

68
00:03:27,550 --> 00:03:33,890
અને કિસ્સાઓમાં ઘણો, તમારા
હાર્ડવેર underutilized હતી.

69
00:03:33,890 --> 00:03:38,830
તેથી, અંતમાં '90s અને પ્રારંભિક 2000 માં,
હાર્ડવેર વર્ચ્યુઅલાઈઝેશન આખા આવ્યા.

70
00:03:38,830 --> 00:03:42,475
અને તમે અહીં જોઈ શકો છો
ચિત્ર, તેઓ કર્યું મૂળભૂત શું

71
00:03:42,475 --> 00:03:46,390
પૂલ બેધ્યાન છે
મફત હાર્ડવેર સાધનો

72
00:03:46,390 --> 00:03:49,680
અને પ્રકારની તે પીરસવામાં
ઉપલા સ્તરોમાં માટે,

73
00:03:49,680 --> 00:03:52,360
આ કિસ્સામાં, એક મહેમાન ઓપરેટીંગ સિસ્ટમ.

74
00:03:52,360 --> 00:03:54,940
>> અને સમગ્ર વિચાર
વર્ચ્યુઅલ મશીનો સમગ્ર આવ્યા હતા

75
00:03:54,940 --> 00:03:59,110
અને તે ખરેખર મેઘ મદદ કરી
આજે આપણે જાણીએ છીએ કમ્પ્યુટિંગ.

76
00:03:59,110 --> 00:04:02,730
તેથી તે શું અર્થ થાય છે તમે છે
બહુવિધ VMs ચલાવી શકો છો, જે

77
00:04:02,730 --> 00:04:06,720
બહુવિધ રન ટાઇમ સ્ટેકનું અર્થ થાય છે, બહુવિધ
એક જ ભૌતિક મશીન પર અરજી.

78
00:04:06,720 --> 00:04:10,570

79
00:04:10,570 --> 00:04:16,440
>> આ ચોક્કસપણે સાથે મદદ કરી હતી
એપ્લિકેશન જમાવટ ઝડપ.

80
00:04:16,440 --> 00:04:17,629
ડેફિનેટલી ખર્ચ સાથે.

81
00:04:17,629 --> 00:04:22,810
તમે જાઓ અને ખર્ચ કરવાની જરૂર નથી
ઊર્જા, સમય, અને સાધનો રેક

82
00:04:22,810 --> 00:04:26,210
વધુ સર્વરો વધુ Compute મેળવવા માટે.

83
00:04:26,210 --> 00:04:30,950
અને ઝડપ ખરેખર લાવી
તે સાધનો વધુ ઝડપી છે.

84
00:04:30,950 --> 00:04:31,450
ગ્રેટ.

85
00:04:31,450 --> 00:04:34,320
>> તેથી અમે અધિકાર, દુનિયામાં ભૂખમરો હલ?

86
00:04:34,320 --> 00:04:36,390
ના, નથી ખરેખર.

87
00:04:36,390 --> 00:04:42,410
તેથી, વર્ચ્યુઅલાઈઝેશન તે ખૂબ તરીકે
વાસ્તવમાં સમસ્યા સંબોધવા મદદ કરી હતી,

88
00:04:42,410 --> 00:04:45,460
તે ખરેખર રજૂ
પડકારો ઘણો.

89
00:04:45,460 --> 00:04:49,210
ચોક્કસપણે આ હાઇપરવિઝર
જટિલતા ઘણો રજૂ

90
00:04:49,210 --> 00:04:53,820
તે અંતર્ગત સંભાળવા
સાધનો પૂલ.

91
00:04:53,820 --> 00:04:57,910
>> તે અર્થમાં ભારે છે તે પહેલાં
તમે એક ઓપરેટિંગ સિસ્ટમ હતી, જે

92
00:04:57,910 --> 00:05:01,830
ડિસ્ક પર ત્રણ, ચાર શોના જેવી છે.

93
00:05:01,830 --> 00:05:04,230
હવે, તમે 10 મશીનો હોય તો
એક હાર્ડવેર પર

94
00:05:04,230 --> 00:05:09,060
તમે તે ગુણાકાર છે
મશીનો સંખ્યા દ્વારા.

95
00:05:09,060 --> 00:05:11,440
તે ચોક્કસપણે વધુ છે
એક અર્થમાં ખર્ચાળ તમે હજુ પણ

96
00:05:11,440 --> 00:05:14,430
માટે પરવાના મેળવવા માટે હોય છે
વર્ચ્યુઅલાઈઝેશન ટેક્નોલોજી

97
00:05:14,430 --> 00:05:18,210
તે ઓપન સોર્સ નથી તો.

98
00:05:18,210 --> 00:05:21,120
>> પરંતુ, ચાલો બધા લેવા ન દો
વર્ચ્યુઅલાઈઝેશન ક્રેડિટ.

99
00:05:21,120 --> 00:05:27,530
શું થયું છે કારણ કે ત્યાં છે
રન ટાઇમ સ્ટેકનું અને સોફ્ટવેર ઘણાં ઘણો

100
00:05:27,530 --> 00:05:33,900
સક્રિય કરવામાં આવ્યા હતા કે ટેકનોલોજી
તમે વિચાર આપની સમક્ષ હતા દ્વારા કેવી રીતે ઝડપી

101
00:05:33,900 --> 00:05:38,040
ક્લાઉડ તેજી સાથે સાધનો છે.

102
00:05:38,040 --> 00:05:46,675
>> તેથી, આજે એક એપ્લિકેશન અથવા સેવાઓ કરી શકો છો
નીચેના રનટાઇમને કોઈપણ ઉપયોગ કરી

103
00:05:46,675 --> 00:05:47,216
અથવા ડેટાબેઝોને.

104
00:05:47,216 --> 00:05:50,250

105
00:05:50,250 --> 00:05:56,070
PHP, Python, MySQL, Redis, whatnot.

106
00:05:56,070 --> 00:05:59,740
તેથી જટિલતા ઘણો આ છે
રન ટાઇમ સ્ટેકનું સંખ્યા ખરેખર લાવવા માટે

107
00:05:59,740 --> 00:06:02,210
એક સેવા.

108
00:06:02,210 --> 00:06:07,300
અને તે સાથે, તમે ઘણો હતો
અંતર્ગત સાધનો અથવા ઇન્ફર્ા ટર્ક્ચર

109
00:06:07,300 --> 00:06:15,210
પ્રકારો જમાવો ચકાસવા અને મૂળભૂત માટે
તે કાર્યક્રમો ઉત્પાદન લેવા

110
00:06:15,210 --> 00:06:16,900
કે તમે વિકાસ કરી રહ્યાં છો.

111
00:06:16,900 --> 00:06:21,950
>> તમારા ટીમો છે, ખાસ કરીને કારણ કે
તે એપ્લિકેશન્સ પર કામ ઉગાડવામાં,

112
00:06:21,950 --> 00:06:25,310
ઘણો છે
જટિલતા અને પડકારો

113
00:06:25,310 --> 00:06:31,660
કે તેની ખાતરી કરવા માટે લાવવામાં આવ્યા હતા
આ cycle-- મૂળભૂત એપ્લિકેશન

114
00:06:31,660 --> 00:06:34,040
વિકાસ ચક્ર છે,
ખરેખર સફળ.

115
00:06:34,040 --> 00:06:40,440
તેથી, હકીકત એ છે કે તમારી અરજી
તમારા સ્થાનિક VM પર સ્થાનિક રીતે કામ કરે છે

116
00:06:40,440 --> 00:06:47,480
તમારા સાથીદાર બાંહેધરી નથી આપતું કે
એ જ પરિણામો અપેક્ષા રહ્યું છે.

117
00:06:47,480 --> 00:06:51,330
>> અને ઓપરેશન્સ ટીમ હોય છે ત્યારે
તમે શું લઈ જવામાં

118
00:06:51,330 --> 00:06:54,480
અને ઉત્પાદન તે જમાવવા
સ્કેલ, પણ કોઈ ગેરંટી છે

119
00:06:54,480 --> 00:06:56,730
કે ખરેખર શું ચાલી રહ્યું છે છે.

120
00:06:56,730 --> 00:07:00,900
તેથી આ એક ખરેખર સાથે નહીં
પ્રશ્ન ગુણ ઘણો big--

121
00:07:00,900 --> 00:07:07,700
પડકારો ઘણો ખરેખર
એ જ રીતે પાછા દિવસોમાં સામનો કરવો પડ્યો હતો.

122
00:07:07,700 --> 00:07:12,280
અને તે અમને યાદ
શિપિંગ ઉદ્યોગ.

123
00:07:12,280 --> 00:07:14,280
>> શિપિંગ ઉદ્યોગ તેથી
માલ ઘણો હતો,

124
00:07:14,280 --> 00:07:16,190
તરીકે તમે ડાબી બાજુ પર જોઈ શકો છો.

125
00:07:16,190 --> 00:07:19,840
અને જમણી બાજુ પર,
ઘણો, મૂળભૂત રીતે છે

126
00:07:19,840 --> 00:07:22,160
માર્ગો તે માલ જહાજ.

127
00:07:22,160 --> 00:07:26,040
અને શું એક દંપતી તરીકે થાય છે
લોકો, મળીને આવ્યા હતા અને જણાવ્યું હતું કે

128
00:07:26,040 --> 00:07:29,600
અમે કેવી રીતે પ્રમાણિત કરવાની જરૂર છે
અમે ખરેખર તે માલ જહાજ.

129
00:07:29,600 --> 00:07:33,280
અને તેજી, તમે છે
intermodal શીપીંગ કન્ટેનર.

130
00:07:33,280 --> 00:07:38,970
>> તેથી તેઓ સૌથી વધુ પર સંમત
કન્ટેનર માટે સામાન્ય કદ.

131
00:07:38,970 --> 00:07:40,160
કેવી રીતે તેમને નિયંત્રિત કરવા માટે.

132
00:07:40,160 --> 00:07:44,560
ચોક્કસ શું પદ્ધતિ તમે જરૂર
તેમને લાવવા અને તેમને અનલોડ.

133
00:07:44,560 --> 00:07:49,590
અને તેથી, તે ખરેખર
શિપિંગ ઉદ્યોગ મદદ કરી હતી.

134
00:07:49,590 --> 00:07:55,250
હવે કરતાં વધુ 90% ધ્યાન પરિવહન
વૈશ્વિક તે કન્ટેનર ઉપયોગ કરી રહ્યા છો.

135
00:07:55,250 --> 00:08:01,010
અને તે ચોક્કસપણે ઘટે
ખર્ચ તેમજ

136
00:08:01,010 --> 00:08:03,400
શીપીંગ કારણે નુકસાની.

137
00:08:03,400 --> 00:08:09,660
>> તેથી અમે આ જ મોડલ લેવા અને અમે
બે એપ્લિકેશન વિકાસ સોફ્ટવેર અરજી

138
00:08:09,660 --> 00:08:13,080
અર્થમાં સ્થાપત્ય,
કે કન્ટેનરાઈઝેશન

139
00:08:13,080 --> 00:08:15,842
એક સ્તર ઉપર વર્ચ્યુઅલાઈઝેશન લીધો હતો.

140
00:08:15,842 --> 00:08:17,800
તેથી તેના બદલે કે કરી ના
હાર્ડવેર સ્તરે,

141
00:08:17,800 --> 00:08:22,060
તે ઓપરેટિંગ વધુ બન્યા
સિસ્ટમ સ્તર વર્ચ્યુઅલાઈઝેશન.

142
00:08:22,060 --> 00:08:26,450
>> અને અમે દરેક આપીને તે કરવા
તેના પોતાના હળવા એપ્લિકેશન,

143
00:08:26,450 --> 00:08:31,180
અલગ, runnable, અને
પોર્ટેબલ, સૌથી અગત્યનું,

144
00:08:31,180 --> 00:08:35,049
એક માર્ગ ખરેખર પેકેજ
ચલાવવા માટે જરૂર છે કે જે બધું.

145
00:08:35,049 --> 00:08:36,100
ગમે તે ચલાવી શકાય છે.

146
00:08:36,100 --> 00:08:42,039
તેથી, અનુલક્ષીને તમે તેના પર ચાલી રહ્યાં છો, તો
સ્થાનિક dev પર્યાવરણ, તમારા ઉત્પાદન

147
00:08:42,039 --> 00:08:44,490
પર્યાવરણ, તમારા સ્ટેજીંગ અથવા પરીક્ષણ.

148
00:08:44,490 --> 00:08:47,700
કોઈ બાબત અંતર્ગત શું
ઈન્ફ્રાસ્ટ્રક્ચર છે,

149
00:08:47,700 --> 00:08:51,410
તમે એક કાર્યાત્મક કામ એપ્લિકેશન હતી.

150
00:08:51,410 --> 00:08:54,100

151
00:08:54,100 --> 00:09:01,800
>> જેથી મૂળભૂત રીતે બરાબર શું છે
કન્ટેનર આ સમસ્યા માટે નથી.

152
00:09:01,800 --> 00:09:04,070
તેઓ દ્વારા તે સંબોધવા
આવા રીતે તે પેકેજ

153
00:09:04,070 --> 00:09:09,490
તે તૈનાત છે કે ખાતરી કરી શકો છો કે
સફળતાપૂર્વક તે રહે છે જ્યાં કોઈ બાબત.

154
00:09:09,490 --> 00:09:12,120
તમે જઈ રહ્યાં છો, તેથી જો
જેમ કે, બોબ તે હજુ પણ બરાબર છે.

155
00:09:12,120 --> 00:09:17,860
તમે મને કહી રહ્યો છું શું સાથે ગેરસમજ કરી રહ્યાં છો,
હું તેના પર elaborating કરી જાઉં છું.

156
00:09:17,860 --> 00:09:20,900
>> તેથી કેવી રીતે Docker પોતે કરે છે
આ ચિત્ર માં ફિટ?

157
00:09:20,900 --> 00:09:26,335
તેથી Docker એક ઓપન પ્લેટફોર્મ છે
સરળતાથી સરળતાથી ભાર મૂકે છે,

158
00:09:26,335 --> 00:09:30,500
, જહાજ નિર્માણ ચલાવવા માટે,
હળવા પોર્ટેબલ સ્વ

159
00:09:30,500 --> 00:09:33,440
ગમે ત્યાં પૂરતી એપ્લિકેશન કન્ટેનર.

160
00:09:33,440 --> 00:09:37,660
તમે આ કંઈક લેવા તેથી જો
ચર્ચા, નીચેની લેવા વિનંતી.

161
00:09:37,660 --> 00:09:40,980
>> તમે તમારી એપ્લિકેશન ચાલી રહ્યુ હોય તો
સ્થાનિક અને તમે તેને વિકસાવવામાં

162
00:09:40,980 --> 00:09:45,930
આ Docker પ્લેટફોર્મ મદદથી અપેક્ષા
તે સફળતાપૂર્વક જમાવટ કરી છે.

163
00:09:45,930 --> 00:09:49,380
કોઈ બાબત શું છે
અંતર્ગત ઇન્ફ્રાસ્ટ્રક્ચર.

164
00:09:49,380 --> 00:09:53,830
તમે Docker હોય તો
અને તે પછી, કન્ટેનર કામ કરી રહ્યા છે

165
00:09:53,830 --> 00:09:58,130
લાંબા તરીકે Docker છે, કારણ કે
અન્ય side-- પર એન્જિન

166
00:09:58,130 --> 00:10:02,190
તમારી કામગીરી ઈન્ફ્રાસ્ટ્રક્ચર તો
તે શું કોઇ મેઘ ઉપયોગ કરી રહ્યા છે

167
00:10:02,190 --> 00:10:06,680
છે AWS, અથવા Google ના, અથવા માઈક્રોસોફ્ટ,
અથવા જાહેર વાદળો કોઇ,

168
00:10:06,680 --> 00:10:10,010
અથવા તમારા પોતાના મેઘ, અથવા તમારા ખુલ્લા સ્ટેક
મેઘ, અથવા તમારા સ્થાનિક પર્યાવરણ.

169
00:10:10,010 --> 00:10:11,970
>> તમે એન્જિન હોય, તો
ચાલી રહ્યું છે, તેનો અર્થ એ કે

170
00:10:11,970 --> 00:10:14,537
તે હોઈ ચાલે છે
સફળતાપૂર્વક ત્યાં જમાવટ.

171
00:10:14,537 --> 00:10:16,620
તે ચાલી કરી રહ્યું છે
બરાબર એ જ વર્તન

172
00:10:16,620 --> 00:10:21,480
તમે તેને architected તરીકે હોય છે.

173
00:10:21,480 --> 00:10:26,080
અમે at-- જોવા તેથી જો હું જાઉં છું
શું ખરેખર મારફતે જાઓ

174
00:10:26,080 --> 00:10:29,160
Docker મુખ્ય ઘટકો છે.

175
00:10:29,160 --> 00:10:31,060
>> તેથી એન્જિન Docker મુખ્ય છે.

176
00:10:31,060 --> 00:10:32,770
તે મગજ છે.

177
00:10:32,770 --> 00:10:39,360
તે મકાન, શિપિંગ orchestrates
અને જમાવવા અને વ્યવસ્થા

178
00:10:39,360 --> 00:10:41,570
કન્ટેનર પોતાને.

179
00:10:41,570 --> 00:10:45,160
I એન્જિન શું કરે છે માં ડિગ પડશે
બીજા વધુ વિગતો.

180
00:10:45,160 --> 00:10:47,740

181
00:10:47,740 --> 00:10:51,720
મૂળભૂત રીતે, ડોક્ટર બાંધવામાં આવી હતી કારણ કે
ક્લાઈન્ટ સર્વર આર્કિટેક્ચર આસપાસ,

182
00:10:51,720 --> 00:10:56,630
જેથી સાથે વાર્તાલાપ કરવા માટે
એન્જિન તમે ક્લાઈન્ટ અમુક પ્રકારના જરૂર છે.

183
00:10:56,630 --> 00:11:01,200
>> છબીઓ નમૂના છે
જેમાંથી બનાવવામાં આવે છે કન્ટેનર.

184
00:11:01,200 --> 00:11:06,800
તેથી છબીઓ મૂળભૂત છે
માત્ર સ્થિર ફાઈલો.

185
00:11:06,800 --> 00:11:08,740
નમૂનાઓ અને કન્ટેનર
ખરેખર શું છે છે

186
00:11:08,740 --> 00:11:12,280
રનટાઈમે ચાલી રહ્યું છે તે
તમારી અરજી સેવા આપતા હોય છે

187
00:11:12,280 --> 00:11:15,150
અથવા માહિતી સાથે કંઈક કરી.

188
00:11:15,150 --> 00:11:19,020
>> રજીસ્ટ્રી એક સમસ્યા તરીકે સંબોધવામાં આવે છે
તમે કેવી રીતે ખરેખર છબીઓ વિતરિત કરે છે.

189
00:11:19,020 --> 00:11:23,230
તેથી જો તમે એક છબી શેર કરવાની જરૂર હોય તો
તમે તમારા સાથીદાર પર કામ કર્યું

190
00:11:23,230 --> 00:11:27,220
અથવા ઓપ્સ ટીમ માટે, તમે
રજીસ્ટ્રી ઉપયોગ ઉપયોગ કરે છે.

191
00:11:27,220 --> 00:11:31,720
તમે એક ઓપન સોર્સ ડાઉનલોડ કરી શકો છો
તે આવૃત્તિ Docker પર કામ કર્યું કે

192
00:11:31,720 --> 00:11:33,150
અને સ્ત્રોત ખોલો.

193
00:11:33,150 --> 00:11:38,040
>> અથવા તમે Docker મદદ ઉપયોગ કરી શકો છો,
જે મેઘ આવૃત્તિ છે

194
00:11:38,040 --> 00:11:40,130
દબાણ અને ત્યાં છબીઓ બહાર ખેંચી.

195
00:11:40,130 --> 00:11:41,160
કે એક વિશાળ વસ્તુ છે.

196
00:11:41,160 --> 00:11:44,520
એક વિશાળ છે કારણ કે
Docker આસપાસ ઇકોસિસ્ટમ અને તે

197
00:11:44,520 --> 00:11:48,960
ખરેખર ભારે કેન્દ્ર ઉપયોગ.

198
00:11:48,960 --> 00:11:59,780
>> તેથી અહીં સારાંશ માટે, આ છે કેવી રીતે
ઓછામાં ઓછા Docker વર્કફ્લો ક્લાઈન્ટ.

199
00:11:59,780 --> 00:12:04,040
તમે યજમાન સાથે વાર્તાલાપ
આ કિસ્સામાં તે Docker ડિમનોને છે.

200
00:12:04,040 --> 00:12:06,490
તે એન્જિન તરીકે જ વાત છે.

201
00:12:06,490 --> 00:12:09,690
તમે શું આદેશો જેવા
Docker, ખેંચે છે, રન બિલ્ડ.

202
00:12:09,690 --> 00:12:14,280
અને એન્જિન પોતે જાય
અને તે વસ્તુઓ કરે છે.

203
00:12:14,280 --> 00:12:18,010
>> તેથી ક્યાં તો તે સાથે સંપર્ક
રજીસ્ટ્રી તે છબીઓ ખેંચવાનો

204
00:12:18,010 --> 00:12:19,670
અને ઈમેજો સ્તરો.

205
00:12:19,670 --> 00:12:25,030
તમે જમાવટ કરવા માંગો છો, તો ચલાવવા શું
કન્ટેનર, તેમને નીચે ફેંકવું, તેમને મારી નાખે છે

206
00:12:25,030 --> 00:12:25,730
whatnot.

207
00:12:25,730 --> 00:12:32,190
તેથી આ વર્કફ્લો સારાંશ
આ તમામ ઘટકોને છે.

208
00:12:32,190 --> 00:12:34,710
>> તમે દરેક લેવા જેથી જો
પોતે દ્વારા ઘટક.

209
00:12:34,710 --> 00:12:37,690
તેથી એન્જિન, તે માત્ર એક ડિમન છે.

210
00:12:37,690 --> 00:12:40,800
તે પ્રકારની આધાર આપવા માટે તે રમવા પડશે
Linux પર તે કરે છે, કારણ કે

211
00:12:40,800 --> 00:12:44,380
ચોક્કસ Linux કર્નલ લક્ષણો જરૂરી છે.

212
00:12:44,380 --> 00:12:48,820
પરંતુ વિન્ડોઝ કામ કરી રહી છે
આ જ વાત કરી છે.

213
00:12:48,820 --> 00:12:53,720
આધારભૂત પ્રયત્ન માનવામાં આવે છે
વિન્ડોઝ સર્વર 2016 દ્વારા.

214
00:12:53,720 --> 00:13:01,500
>> સાથે જ, ફરીથી, આ જવાબદારીઓ
એન્જિન છે, અથવા, છબીઓ બનાવવા માટે છે.

215
00:13:01,500 --> 00:13:05,340
આ Docker માંથી છબીઓ ખેંચો
હબ અથવા તમારા પોતાના રજીસ્ટ્રી.

216
00:13:05,340 --> 00:13:07,840
તમે તે છબીઓ સાથે કરવામાં રહ્યાં છો, તો
અથવા તમે એક નવી છબીઓ બનાવવા

217
00:13:07,840 --> 00:13:14,770
તમે રજિસ્ટ્રી તે પાછા દબાણ કરી શકો છો
અન્ય ટીમો તેમને વિતરિત કરવા માટે.

218
00:13:14,770 --> 00:13:18,300
>> અને પ્રયાસ કરી સ્થાનિક રીતે સમાવી
અને કન્ટેનર જીવન ચક્ર વ્યવસ્થા

219
00:13:18,300 --> 00:13:19,260
સ્થાનિક.

220
00:13:19,260 --> 00:13:22,010
તે HTTP REST API આસપાસ બાંધવામાં આવે છે.

221
00:13:22,010 --> 00:13:24,480
તેથી ટેકનિકલી તમે કરી શકો છો
તમારા પોતાના ક્લાઈન્ટ લખવા

222
00:13:24,480 --> 00:13:31,650
જ્યાં સુધી તે ખૂબ જ છે, જે HTTP ઉપયોગ કરે છે,
પ્રમાણભૂત પદ્ધતિ એન્જિન સાથે વાત કરવા માટે

223
00:13:31,650 --> 00:13:33,110
અને અન્ય સેવાઓ ઘણો.

224
00:13:33,110 --> 00:13:35,780
અને તમે જોઈ શકો છો
અહીં અનુલક્ષીને

225
00:13:35,780 --> 00:13:39,010
શું ઈન્ફ્રાસ્ટ્રક્ચરની
તમે બધા can-- તરીકે લાંબા સમય સુધી છે,

226
00:13:39,010 --> 00:13:42,170
તમે ઓપરેટિંગ જરૂર
સિસ્ટમ Linux ખાસ.

227
00:13:42,170 --> 00:13:45,460
>> અને તમે Docker એન્જિન સ્થાપિત કરી શકો છો
કે ટોચ પર અને તે ચાલી છે

228
00:13:45,460 --> 00:13:48,970
અને તે મૂળભૂત રીતે, orchestrates
બધા આ એપ્લિકેશન એક, બે,

229
00:13:48,970 --> 00:13:51,530
અને ત્રણ વાસ્તવિક કન્ટેનર છે.

230
00:13:51,530 --> 00:13:53,990
જેથી એન્જિન છે.

231
00:13:53,990 --> 00:13:58,040
હું અગાઉ ઉલ્લેખ કર્યો છે કારણ કે
તમે એન્જિન સાથે વાર્તાલાપ કરવાની જરૂર

232
00:13:58,040 --> 00:13:59,200
ક્લાઈન્ટ છે.

233
00:13:59,200 --> 00:14:03,180
>> પરંતુ ખરેખર તમે સ્થાપિત કરો ત્યારે
તેની સાથે Docker, જહાજો.

234
00:14:03,180 --> 00:14:06,110
તેથી તે સ્થાપિત નહીં
જેથી તે એક બાઈનરી છે.

235
00:14:06,110 --> 00:14:11,830
અને તમે લોકલ કોલ્સ કરી શકો છો
તમારા Docker એન્જિન છે.

236
00:14:11,830 --> 00:14:14,040
દૂરસ્થ એન્જિન્સ માટે અથવા દૂરસ્થ કોલ્સ.

237
00:14:14,040 --> 00:14:16,600

238
00:14:16,600 --> 00:14:19,590
, કારણ કે તે HTTP નો ઉપયોગ કરે છે
હું અગાઉ ઉલ્લેખ કર્યો છે.

239
00:14:19,590 --> 00:14:24,200
કહેવાય GUI ક્લાઈન્ટ છે
Docker થી Kitematic.

240
00:14:24,200 --> 00:14:26,390
અને ત્યાં ચોક્કસપણે છે
અન્ય લોકો ઘણો

241
00:14:26,390 --> 00:14:29,740
જે ઘણો મકાન છે
મૂળભૂત અમલ કે GUIs

242
00:14:29,740 --> 00:14:32,980
કેટલાક HTTP એન્જિન સાથે વાત કરવા માટે કહે છે.

243
00:14:32,980 --> 00:14:35,920

244
00:14:35,920 --> 00:14:39,280
>> જસ્ટ કેટલાક નમૂના આદેશો.

245
00:14:39,280 --> 00:14:44,620
તમે Docker આવૃત્તિ હોય, તો તે કરશે
તમે ક્લાઈન્ટ આવૃત્તિ બતાવવા તેમજ

246
00:14:44,620 --> 00:14:47,030
સર્વર આવૃત્તિ.

247
00:14:47,030 --> 00:14:49,500
તમે Docker માહિતી કરશો તો તે ચાલશે
તમે બધી માહિતી કહેવું

248
00:14:49,500 --> 00:14:54,300
કેટલા કન્ટેનર ચાલી રહ્યા છે તે વિશે
અથવા બનાવનાર, તમે કેટલા છબીઓ,

249
00:14:54,300 --> 00:14:56,530
અને તેથી પર અને તેથી પર.

250
00:14:56,530 --> 00:15:01,850
>> અહીં હું આગામી છે,
છેલ્લા બોક્સ, હું ડોક્ટર ચાલે છે.

251
00:15:01,850 --> 00:15:04,970
જેથી હું ખરેખર છું કેવી રીતે
કન્ટેનર બનાવવા.

252
00:15:04,970 --> 00:15:08,960
અને હું હેલો વર્લ્ડ પડઘો તે આપી રહ્યો છું
અને બીજા અને whatnot માટે ઊંઘ.

253
00:15:08,960 --> 00:15:12,830
અને તમે જોઈ શકો છો
પરિણામ. તેથી તે ચાલુ છે.

254
00:15:12,830 --> 00:15:16,930
અને Linux PS માટે સમાન છે, તમે જોઈ શકો છો
આ કિસ્સામાં તમામ પ્રક્રિયાઓ અને,

255
00:15:16,930 --> 00:15:18,540
ચાલી રહેલ બધા કન્ટેનર.

256
00:15:18,540 --> 00:15:23,430
આ એક માતાનો ઉલ્લેખ પાછા
કન્ટેનર હું હમણાં બનાવેલ છે.

257
00:15:23,430 --> 00:15:27,560
>> તેથી, આ છે, કારણ કે ખરેખર મહત્વનું છે
જેમ તે થોડો ગૂંચવણમાં મૂકે હોઈ શકે છે.

258
00:15:27,560 --> 00:15:33,050
તેથી છબીઓ વાંચી જ છે
ફાઇલો સંગ્રહ, અધિકાર?

259
00:15:33,050 --> 00:15:37,000
તેઓ અમારા કન્ટેનર પર આધારિત છે શું છે.

260
00:15:37,000 --> 00:15:40,340
પરંતુ તેઓ માત્ર ને માત્ર-વાંચી રહ્યાં છો.

261
00:15:40,340 --> 00:15:44,330
તેથી જો તમે એક આધાર છબી સાથે બંધ શરૂ કરો.

262
00:15:44,330 --> 00:15:50,180
તેથી તે, ઓએસ જેવા નકલ કરે છે
ઉબુન્ટુ, CentOS, whatnot આધાર છબી.

263
00:15:50,180 --> 00:15:53,990
અને પછી તમે ટોચ પર નિર્માણ શરૂ
કે, અમુક સ્તરો છે, કે જે કરશે

264
00:15:53,990 --> 00:16:00,010
તમારા માટે છબી, અંતે અહીં પરિણમી.

265
00:16:00,010 --> 00:16:03,220
>> અને તે સ્તરો દરેક
પિતૃ છબી હોવી જોઇએ

266
00:16:03,220 --> 00:16:06,690
તે જ્યારે તે સંદર્ભિત કરશે નહીં
ખરેખર બનાવવા માંગે છે.

267
00:16:06,690 --> 00:16:09,922
તેઓ અર્થમાં, નિર્વિકાર છે
તેઓ રહ્યાં છો કારણ કે ફક્ત વાંચવા કે

268
00:16:09,922 --> 00:16:11,630
તમે ખરેખર નથી કરી શકો છો
તેમને ફેરફારો કરો.

269
00:16:11,630 --> 00:16:17,540
તમે બનાવવા માટે તેમને ઉપયોગ કરી શકો છો
એક છબી છે, કન્ટેનર, જે

270
00:16:17,540 --> 00:16:23,530
બધા વારાફરતી ફોન કરશે
તે નીચે જરૂરી છબીઓ.

271
00:16:23,530 --> 00:16:26,400
>> તમે ફેરફાર કરી શકો છો
એક અલગ સ્તર પર,

272
00:16:26,400 --> 00:16:28,810
તે હું પડશે પુનર્લેખન સ્તર છે
એક બીજા વિશે વાત કરો.

273
00:16:28,810 --> 00:16:31,350
પરંતુ તે સ્તરો દરેક
ક્યારેય બદલાઈ છે.

274
00:16:31,350 --> 00:16:34,300

275
00:16:34,300 --> 00:16:38,670
મૂળભૂત છબીઓ કંઈક ઉપયોગ
યુનિયન સિસ્ટમ, UFS ફાઇલ કહેવાય છે.

276
00:16:38,670 --> 00:16:42,280
અને વિવિધ સંગ્રહ છે
આ ટેકનોલોજીનો ઉપયોગ કે પાશ્વભાગોની.

277
00:16:42,280 --> 00:16:49,430
અને શું અર્થ એ થાય કે તે છે
અલગ ફાઈલ સિસ્ટમો સાથે લાવે છે

278
00:16:49,430 --> 00:16:51,190
તેમને એક જેવો બનાવવા માટે.

279
00:16:51,190 --> 00:16:54,460
>> જેથી તમે, ખરેખર કરી શકો છો
અરજી પરિપ્રેક્ષ્ય,

280
00:16:54,460 --> 00:16:59,570
તમે બતાવે છે કે એક દૃશ્ય એક ટોચ છે
બધા અલગ અલગ ફાઈલ સિસ્ટમ જરૂરી

281
00:16:59,570 --> 00:17:01,120
કે એપ્લિકેશન ચલાવવા માટે.

282
00:17:01,120 --> 00:17:04,400
પરંતુ તેઓ આ પર, ખરેખર છો,
તેઓ અલગ સ્થળોએ ખરેખર છો

283
00:17:04,400 --> 00:17:06,410
અને ઉપયોગ કરવામાં આવી રહ્યો
તેમજ અન્ય કન્ટેનર.

284
00:17:06,410 --> 00:17:09,569

285
00:17:09,569 --> 00:17:14,410
>> તમે અહીં જોઈ શકો છો જેથી કે
અમે ડિમન છબી સાથે શરૂ કરો, તો

286
00:17:14,410 --> 00:17:18,619
પછી આધાર છબી, અને
અમે માં જાઓ અને [ઉમેરો? Emacs?]

287
00:17:18,619 --> 00:17:20,720
અને પછી તે અન્ય સ્તર છે.

288
00:17:20,720 --> 00:17:21,916
અને પછી અપાચે ઉમેરો.

289
00:17:21,916 --> 00:17:22,790
કે બીજા સ્તર છે.

290
00:17:22,790 --> 00:17:25,470
અને પછી અમે પસાર
કે કન્ટેનર.

291
00:17:25,470 --> 00:17:29,760
તે છબીઓ દરેક
તે સ્તરો દરેક,

292
00:17:29,760 --> 00:17:35,530
અલગ છે અને હોઈ શકે છે
અન્ય કન્ટેનર દ્વારા ફરીથી.

293
00:17:35,530 --> 00:17:40,070
>> તમે પોતાને કન્ટેનર પર નજર કરો તો,
તેઓ કોઈક VM જેવા જેવા છો

294
00:17:40,070 --> 00:17:41,930
પરંતુ તે જ સમયે સારવાર ન.

295
00:17:41,930 --> 00:17:49,180
તેથી, તેઓ નથી, ટેકનિકલી,
તેમને નીચે સંપૂર્ણ ઓપરેટિંગ સિસ્ટમ.

296
00:17:49,180 --> 00:17:52,630
તેઓ એક કર્નલ વાપરો
યજમાન ઓપરેટિંગ સિસ્ટમ.

297
00:17:52,630 --> 00:17:54,440
અને તેઓ કે જે ટોચ પર બિલ્ડ.

298
00:17:54,440 --> 00:17:56,250
તેઓ જોવા કેવી રીતે નકલ.

299
00:17:56,250 --> 00:18:00,710
તેઓ તેમના રુટ ફાઈલ નકલ
ઓપરેટિંગ સિસ્ટમ સિસ્ટમ.

300
00:18:00,710 --> 00:18:04,930
પરંતુ તેઓ વાસ્તવમાં પ્રતિકૃતિ નથી.

301
00:18:04,930 --> 00:18:12,080
>> તેથી, તેના બદલે નિર્વિકાર સ્તરો કર્યા છે,
કન્ટેનર છે, જે છેલ્લા સ્તર,

302
00:18:12,080 --> 00:18:14,690
પોતે છે, તે વાંચી લખી સ્તર છે.

303
00:18:14,690 --> 00:18:17,350
તે પણ પ્રક્રિયાઓ ચાલે
તમારી અરજી.

304
00:18:17,350 --> 00:18:23,530
અને તે અંતર્ગત સ્તરો પર આધાર રાખે છે.

305
00:18:23,530 --> 00:18:26,730
દરેક કન્ટેનર છે
ઇમેજમાંથી બનાવી છે.

306
00:18:26,730 --> 00:18:32,450
અને તે છબી એક હોઈ શકે છે
સ્તર અથવા multilayer છબી.

307
00:18:32,450 --> 00:18:37,200
>> અને હું અહીં નોંધ કરવા માંગો છો
, Docker ભારે ઉપયોગ કરે છે

308
00:18:37,200 --> 00:18:40,370
અથવા કોપી ઓન રાઇટ પદ્ધતિ પર આધારિત છે.

309
00:18:40,370 --> 00:18:44,350
તેથી જો તમે ન હોય તો, ખરેખર, કે
કન્ટેનર ફેરફારો કર્યા,

310
00:18:44,350 --> 00:18:45,930
તે વધારાની જગ્યા લેવા નથી ચાલી રહ્યું છે.

311
00:18:45,930 --> 00:18:49,600
જેથી મૂળભૂત રીતે તમે કેવી રીતે છે
એક કોપી ઓન રાઇટ સારાંશ.

312
00:18:49,600 --> 00:18:53,820
તે ચોક્કસપણે ઝડપી ચાલી રહ્યું છે
કન્ટેનર માટે બુટ સમય.

313
00:18:53,820 --> 00:18:56,300
તમે બનાવી રહ્યા છો, કારણ કે
કન્ટેનર ફેરફારો

314
00:18:56,300 --> 00:18:57,800
તે પહેલાથી જ ત્યાં છે તે ઉપયોગ કરે છે.

315
00:18:57,800 --> 00:19:01,130

316
00:19:01,130 --> 00:19:02,955
>> તેથી, તે ખરેખર કામ કરે છે કેવી રીતે.

317
00:19:02,955 --> 00:19:06,920

318
00:19:06,920 --> 00:19:14,240
તે ભાગ છે, તે હવે અધિકાર, જેવું છે
ઓછામાં ઓછા બે કી કર્નલ ઉપયોગ કરે છે

319
00:19:14,240 --> 00:19:14,820
વિશેષતા.

320
00:19:14,820 --> 00:19:17,660
અને તે મૂળભૂત રીતે શું છે
અલગતા કે સ્તર બનાવવામાં

321
00:19:17,660 --> 00:19:19,550
કન્ટેનર પોતાને માટે.

322
00:19:19,550 --> 00:19:22,290
તે લક્ષણો છે
નેમસ્પેસેસ અને cgroups.

323
00:19:22,290 --> 00:19:29,870
તેથી નેમસ્પેસેસ કરવા માટે એક માર્ગ છે
, અલગ સાધનો બનાવવા

324
00:19:29,870 --> 00:19:36,290
જેથી કન્ટેનર પોતાની અંદર છે,
માત્ર તમે ચોક્કસ સાધનો જોઈ શકો છો.

325
00:19:36,290 --> 00:19:40,030
આવા નેટવર્કીંગ ઇન્ટરફેસ તરીકે
અથવા ચોક્કસ વપરાશકર્તાઓ અથવા whatnot.

326
00:19:40,030 --> 00:19:44,160
>> અને તે જ દૃશ્યમાન છે અને માત્ર છે
કન્ટેનર અંદર સુલભ.

327
00:19:44,160 --> 00:19:48,290
બીજી બાજુ મર્યાદા પર cgroup
તમે કેવી રીતે તે સાધનો વાપરો.

328
00:19:48,290 --> 00:19:50,950
સીપીયુ, મેમરી, અને ડિસ્ક.

329
00:19:50,950 --> 00:19:53,900
તમે, હું જઈ શકે છે જ્યારે
તે ખરેખર છે અર્થ

330
00:19:53,900 --> 00:19:57,410
by-- વિકસાવવામાં આવ્યા હતા કે જે લક્ષણો
તેઓ Linux કર્નલ ભાગ છો.

331
00:19:57,410 --> 00:20:01,800
તેથી તેઓ ફરી ન હતી
અથવા Docker દ્વારા અનુરૂપિત.

332
00:20:01,800 --> 00:20:03,770
Docker તેમને ઉપયોગ કરે છે.

333
00:20:03,770 --> 00:20:05,560
>> શું ડોક્ટર ખરેખર હતી
અહીં તે ખરેખર છે

334
00:20:05,560 --> 00:20:08,680
યાજના બનાવવા
દરેક કન્ટેનર માટે નેમસ્પેસેસ

335
00:20:08,680 --> 00:20:13,320
અને cgroups બનાવવા તે છે કે જેથી
કન્ટેનર બનાવવા માટે હાસ્યજનક રીતે સરળ

336
00:20:13,320 --> 00:20:14,870
તે લક્ષણો મદદથી.

337
00:20:14,870 --> 00:20:22,910
અલબત્ત, હું વર્ણવ્યા અનુસાર અગાઉ યુનિયન
સિસ્ટમો ફાઇલ અને સાચી કોપી ઓન રાઇટ

338
00:20:22,910 --> 00:20:26,810
ઝડપ અને ડિસ્ક મદદ
કન્ટેનર ઉપયોગ.

339
00:20:26,810 --> 00:20:28,917
>> અને એક વાર તમે વિચાર તમારા
Docker આસપાસ હાથ,

340
00:20:28,917 --> 00:20:32,000
તમે તેને કેવી રીતે ઝડપી જોવા જઈ રહ્યાં છો
ખરેખર કન્ટેનર અને આંસુ સ્પીન યુપી

341
00:20:32,000 --> 00:20:32,500
તેમને નીચે.

342
00:20:32,500 --> 00:20:36,060

343
00:20:36,060 --> 00:20:40,230
તમે પૂછી શકે તો, કેવી રીતે કરી શકો છો
તમે ખરેખર છબીઓ બાંધે છે?

344
00:20:40,230 --> 00:20:45,940
અમે બનાવવા એક પ્રક્રિયા દ્વારા છબીઓ બિલ્ડ
કન્ટેનર અને બનાવવા ફેરફારો બદલતા

345
00:20:45,940 --> 00:20:50,220
તેમને અને તેમને સંગ્રહવાથી
એક છબી બની જાય છે.

346
00:20:50,220 --> 00:20:54,330
>> તેથી તે ચિકન અને
અહીં ઇંડા સંદર્ભ,

347
00:20:54,330 --> 00:20:57,350
બધા કન્ટેનર આવે છે કારણ કે
ચિત્રો અને ઈમેજો આવે થી

348
00:20:57,350 --> 00:21:00,270
પ્રતિબદ્ધ કન્ટેનર,
સૌથી મોટા ભાગ માટે.

349
00:21:00,270 --> 00:21:03,830
ત્રણ વિકલ્પો છે
છબીઓ બનાવવા માટે.

350
00:21:03,830 --> 00:21:06,580
હું વર્ણન કરવા માટે જઇ રહ્યો છું
પ્રથમ અને છેલ્લા.

351
00:21:06,580 --> 00:21:10,060
તમે ક્યાં તો જાતે કરી શકો છો
જાઓ અને કન્ટેનર ચલાવવા

352
00:21:10,060 --> 00:21:14,280
અને તે ફેરફારો કરો,
જેમ તમે કોઇ VM પર શું કરશે

353
00:21:14,280 --> 00:21:17,060
અથવા કોઈપણ ઓપરેટિંગ સિસ્ટમ, જેમ કે
નવા દ્વિસંગીઓ સ્થાપિત તરીકે,

354
00:21:17,060 --> 00:21:19,370
ફાઇલ સિસ્ટમો, અને whatnot ઉમેરી રહ્યા છે.

355
00:21:19,370 --> 00:21:22,620
>> અને પછી તમે બહાર નીકળવા
તમે ત્યાં જોઈ શકો છો.

356
00:21:22,620 --> 00:21:24,330
હું મારી કન્ટેઈનર બહાર નીકળતા છું.

357
00:21:24,330 --> 00:21:26,050
અને પછી હું Docker મોકલવું કરી રહ્યો છું.

358
00:21:26,050 --> 00:21:28,390
અને હું કે સંગ્રહવાથી છું.

359
00:21:28,390 --> 00:21:31,560
તમે અહીં નંબર જોઈ શકો છો
માત્ર એક UUID, અથવા પ્રથમ 12

360
00:21:31,560 --> 00:21:32,810
આ UUID બિટ્સ.

361
00:21:32,810 --> 00:21:34,320
આ UUID અથવા બાઇટ્સ.

362
00:21:34,320 --> 00:21:35,770
અને પછી હું મારા છબી ફોન કરું છું.

363
00:21:35,770 --> 00:21:39,510
તેથી હવે Docker કાળજી લે છે
બધું રેકોર્ડ હું તે કર્યું

364
00:21:39,510 --> 00:21:42,830
અને નવા બનાવવા
તે પર આધારિત છબી.

365
00:21:42,830 --> 00:21:47,080

366
00:21:47,080 --> 00:21:52,560
>> હું ટારબોલ વિશે વાત કરવા જઈ રહ્યો છું
પરંતુ તમે એક વિચાર કરી શકો છો એક માર્ગ છે, ત્યાં

367
00:21:52,560 --> 00:21:58,200
એક બનાવો, અથવા એક બનાવવા
tarballs ઉપયોગ સ્તર છબી.

368
00:21:58,200 --> 00:22:02,650
શું હું આ વિશે વાત કરવા જઈ રહ્યો છું
અને મોટે ભાગે આજે ઉપયોગ થાય છે તે,

369
00:22:02,650 --> 00:22:03,270
Dockerfile છે.

370
00:22:03,270 --> 00:22:07,260
જે ટેકનિકલી પ્રથમ છે
Docker પોતે દ્વારા ઓટોમેટ પગલું.

371
00:22:07,260 --> 00:22:11,920
તેથી Dockerfiles તમે છો કે જે વસ્તુઓ છે
GitHub રેપો ઘણો જોવા જઈ

372
00:22:11,920 --> 00:22:13,150
આજે.

373
00:22:13,150 --> 00:22:16,420
મૂળભૂત રીતે તે માત્ર એક
વર્ણન લખાણ ફાઈલ

374
00:22:16,420 --> 00:22:19,780
બરાબર કેવી રીતે એક છબી બીલ્ડ કરવા.

375
00:22:19,780 --> 00:22:25,540
>> અને દરેક વાક્ય માટે, તે ખરેખર બનાવે છે
કન્ટેનર, તે લીટી ચલાવે છે,

376
00:22:25,540 --> 00:22:30,480
એક માં કે કન્ટેનર આદરે
નવી છબી, અને તમે, મૂળભૂત રીતે,

377
00:22:30,480 --> 00:22:36,160
બધા વારાફરતી કામગીરી માટે તેનો ઉપયોગ
તમે છેલ્લા છબી વિચાર ત્યાં સુધી.

378
00:22:36,160 --> 00:22:39,260
જે મૂળભૂત રીતે
અહીં ઓવરને ધ્યેય અંત.

379
00:22:39,260 --> 00:22:42,420
અને પછી તમે પછી exec--
લખવા તમારા Dockerfile, જે

380
00:22:42,420 --> 00:22:46,750
કેવળ લખાણ છે, તમે Docker કરી
બિલ્ડ કરવા અને ઇમેજ નામ.

381
00:22:46,750 --> 00:22:50,000
>> અને તમે એ છે કે અંતે નિર્દેશ
જ્યાં Dockerfile છે.

382
00:22:50,000 --> 00:22:56,570
અને તમે મારી છબી જોવા માટે અપેક્ષા કરી શકો છો
એક છબી છે કે તમે સ્થાનિક છે.

383
00:22:56,570 --> 00:22:59,100
તેથી તે માત્ર એક દ્રશ્ય છે
પર જાય છે શું ઉદાહરણ.

384
00:22:59,100 --> 00:23:00,820
તમે આધાર છબી સાથે શરૂ કરો.

385
00:23:00,820 --> 00:23:05,150
તમે એક કન્ટેનર માં કે ચાલે છે કે
આધાર ઇમેજ પોતાને બદલી નથી.

386
00:23:05,150 --> 00:23:08,310
પરંતુ તેના બદલે બનાવે
તે ટોચ પર સ્તર લખાણ લખે

387
00:23:08,310 --> 00:23:10,340
જ્યાં તમે ફેરફારો કરો,
જેમાં તમે મોકલવું

388
00:23:10,340 --> 00:23:15,050
અને તમે આ પ્રક્રિયા સુધી પુનરાવર્તન
તમે તમારી અંતિમ છબી મળે છે.

389
00:23:15,050 --> 00:23:20,980
>> અને આમ કરવાથી દ્વારા, દરેક અન્ય બિલ્ડ
પ્રક્રિયા જ સ્તરો ઉપયોગ કરી શકો છો

390
00:23:20,980 --> 00:23:23,870
અને same-- મૂળભૂત
Docker તે સ્તરો કેશ કરે છે.

391
00:23:23,870 --> 00:23:30,040
હું ચોક્કસ જ કરી રહ્યો છું કે જેથી
પ્રક્રિયા, પરંતુ તેના બદલે PHP સ્થાપિત,

392
00:23:30,040 --> 00:23:31,540
હું Python સ્થાપિત છું.

393
00:23:31,540 --> 00:23:34,210
તે અપાચે અને ઉબુન્ટુ વાપરવા માટે ચાલી રહ્યું છે.

394
00:23:34,210 --> 00:23:39,570
જે રીતે જેથી તમે તમારા ડિસ્ક ઉપયોગ કરી રહ્યાં છો.

395
00:23:39,570 --> 00:23:42,330
તે કેશ ઉપયોગ છે
ત્યાં ઉપલબ્ધ છબીઓ.

396
00:23:42,330 --> 00:23:45,320

397
00:23:45,320 --> 00:23:48,840
>> અંતિમ ભાગ રજીસ્ટ્રી છે, જે
તમે તમારી છબીઓ વિતરણ કેવી રીતે છે.

398
00:23:48,840 --> 00:23:52,710
અને, હું અગાઉ ઉલ્લેખ કર્યો છે,
તે એક વાદળ આવૃત્તિ છે,

399
00:23:52,710 --> 00:23:54,290
જે Docker કેન્દ્ર છે.

400
00:23:54,290 --> 00:23:57,550
તમે જાઓ અને અન્વેષણ કરી શકો છો
મૂળભૂત રીતે, ઘણો

401
00:23:57,550 --> 00:24:04,900
તે જાહેર SAS ઉત્પાદન છે કે
તમે હજુ પણ ખાનગી છબીઓ હોઈ શકે છે

402
00:24:04,900 --> 00:24:06,590
પરંતુ જાહેર છબીઓ ઘણો છે.

403
00:24:06,590 --> 00:24:10,580
તે તમે કરી શકો છો, ખરેખર અનલિમિટેડ છે
ત્યાં અનલિમિટેડ જાહેર ઈમેજો દબાણ.

404
00:24:10,580 --> 00:24:13,730
અને આ કેવી રીતે તમે આ કરી શકો છો છે
તમારી ટીમ સાથે સહયોગ કરે છે.

405
00:24:13,730 --> 00:24:17,159
>> તમે રેપો તમે માત્ર તેમને નિર્દેશ કરી શકો છો
અને તેઓ તેને અથવા તમારી છબી ડાઉનલોડ કરી શકો છો

406
00:24:17,159 --> 00:24:18,200
અને તેઓ તેને ડાઉનલોડ કરી શકો છો.

407
00:24:18,200 --> 00:24:21,140

408
00:24:21,140 --> 00:24:24,990
ટોક તેથી પૂરતી.

409
00:24:24,990 --> 00:24:29,110
જે વાસ્તવિક ઝડપી કેટલાક ડેમો જોવા માંગે છે?

410
00:24:29,110 --> 00:24:31,330
બધા અધિકાર.

411
00:24:31,330 --> 00:24:34,050
તેથી અહીં હું હોય છે.

412
00:24:34,050 --> 00:24:37,480
તમે ગાય્ઝ મારા સ્ક્રીન જોવા CA?

413
00:24:37,480 --> 00:24:38,390
બધા અધિકાર.

414
00:24:38,390 --> 00:24:45,810
>> તેથી હું Docker અહીં ચાલતું હોય છે, તેથી હું
આ it's-- ચકાસી શકો છો આવૃત્તિ છે

415
00:24:45,810 --> 00:24:47,510
Docker ચાલી રહ્યું છે.

416
00:24:47,510 --> 00:24:49,320
Docker માહિતી કરી શકો છો.

417
00:24:49,320 --> 00:24:55,730
કેટલા વિશે તમામ માહિતી તપાસો
છબીઓ તેઓ તેથી પર અને તેથી પર હોય છે, અને.

418
00:24:55,730 --> 00:24:58,890
Docker PS, કંઇ ચાલી છે.

419
00:24:58,890 --> 00:25:00,570
તે શ્રેણીબદ્ધ.

420
00:25:00,570 --> 00:25:06,370
>> તેથી હું શું કરવા માંગો છો પ્રથમ વસ્તુ શો છે
તમે સરળતાથી એક કન્ટેનર ચલાવી શકો છો કેવી રીતે.

421
00:25:06,370 --> 00:25:09,350
તેથી સુંદરતા વિશે
ડોક્ટર રન તો ખરેખર

422
00:25:09,350 --> 00:25:14,700
સ્થાનિક એક છબી શોધી નથી,
મૂળભૂત રીતે તે ડોક્ટર હબ વાત

423
00:25:14,700 --> 00:25:17,240
અને ત્યાં તેને શોધવા માટે પ્રયાસ કરે છે
તમારા માટે અને ડાઉનલોડ્સ તે.

424
00:25:17,240 --> 00:25:22,820
તેથી તે Docker સમાવેશ થાય છે
કુદરતી રીતે, આદેશ ખેંચો.

425
00:25:22,820 --> 00:25:26,130
>> તેથી હું Docker રન હેલો વર્લ્ડ કરે છે.

426
00:25:26,130 --> 00:25:28,890

427
00:25:28,890 --> 00:25:31,200
તેથી, પ્રથમ તે ચાલી રહ્યું છે
સ્થિત કરવાનો પ્રયાસ કરો.

428
00:25:31,200 --> 00:25:36,140
નહિંતર, તમે અહીં જોઈ શકો છો,
તે સ્થાનિક રીતે શોધી શક્યા નથી.

429
00:25:36,140 --> 00:25:41,830
હમણા તે માત્ર બે સ્તરો ખેંચાય
કે છબી બનાવી અને હું ચાલી હતી.

430
00:25:41,830 --> 00:25:45,440
હેલ્લો વિશ્વમાં માત્ર મૂળભૂત છે
તમે શું કર્યું છે આઉટપુટ.

431
00:25:45,440 --> 00:25:47,680
તેથી આ સરળ છે,
એક સૌથી સરળ ઉદાહરણો.

432
00:25:47,680 --> 00:25:53,840
તેથી વાસ્તવમાં હું માત્ર ચાલી હતી અને
કન્ટેનર વાસ્તવિક ઝડપી સમાપ્ત.

433
00:25:53,840 --> 00:25:59,500
>> હું તો, run-- અને જે રીતે દ્વારા કરવા માંગો છો
હું તમે જાણો છો કે, સમય કરવા માંગો છો

434
00:25:59,500 --> 00:26:03,572
આ તે કેટલો સમય લે છે છે
ખરેખર સ્પીન યુપી અને તે છે.

435
00:26:03,572 --> 00:26:05,030
અમે મિલિસેકન્ડોમાં તે માપવાની કરી રહ્યાં છો.

436
00:26:05,030 --> 00:26:10,600
તેથી તમે જોઈ શકો છો કેટલી આ કરી શકો છો
ખરેખર તમે ચકાસી શકો પરીક્ષણ મદદ,

437
00:26:10,600 --> 00:26:13,200
પણ પણ જમાવટ.

438
00:26:13,200 --> 00:26:17,221
જેથી એક ઝડપી નોંધ પર છે.

439
00:26:17,221 --> 00:26:18,970
હું આગામી વસ્તુ
કરવા જઇ ખરેખર છે

440
00:26:18,970 --> 00:26:21,930
હું પહેલેથી જ તૈયાર કર્યું છે એક છબી ચલાવો.

441
00:26:21,930 --> 00:26:24,460
તેથી સ્કોર Docker.

442
00:26:24,460 --> 00:26:27,240
-d કહેવું માત્ર એક ધ્વજ છે
તે પૃષ્ઠભૂમિમાં ચલાવવા માટે.

443
00:26:27,240 --> 00:26:30,290
અને -p ચોક્કસ પોર્ટ સોંપે છે.

444
00:26:30,290 --> 00:26:32,670
કારણ કે મૂળભૂત રીતે,
કન્ટેનર, અલગ છે

445
00:26:32,670 --> 00:26:36,080
જેથી તમે બરાબર સ્પષ્ટ કરવા માટે છે
તે કેવી રીતે તેમને ઍક્સેસ કરી શકો છો.

446
00:26:36,080 --> 00:26:41,150
અને આ કિસ્સામાં, હું Docker જણાવું છું
યજમાન પર રેન્ડમ પોર્ટ મેપ

447
00:26:41,150 --> 00:26:44,560
અંદર એક ચોક્કસ પોર્ટ માટે
કન્ટેનર પોતે.

448
00:26:44,560 --> 00:26:47,130

449
00:26:47,130 --> 00:26:56,460
અને તે જ્યાં image-- મૂળભૂત છે
આસ્થાપૂર્વક આ યોગ્ય છે.

450
00:26:56,460 --> 00:27:01,780
>> તેથી તે સમાંતર ડાઉનલોડ્સ દરેક કરે છે
તે સ્તરો તમે અહીં જોઈ શકો છો.

451
00:27:01,780 --> 00:27:06,949
તે સ્તરો બનાવે છે
હું બાંધવામાં કે અંત છબી.

452
00:27:06,949 --> 00:27:08,115
તે બીજી લઈ રહ્યું છે.

453
00:27:08,115 --> 00:27:11,290

454
00:27:11,290 --> 00:27:12,370
અને વોઇલા Query.

455
00:27:12,370 --> 00:27:16,590
>> હું એક Docker PS હોય તો હવે, હું જોઈએ
ચાલી રહ્યું છે તે કંઈક જુઓ.

456
00:27:16,590 --> 00:27:22,250
હું છબી આઈડી જોવા જોઈએ
આ તે બોલ આધારિત હતી

457
00:27:22,250 --> 00:27:23,880
અને આદેશ ચલાવવામાં આવી હતી.

458
00:27:23,880 --> 00:27:28,720
અને તે છે ઍક્સેસ કરવા માટે કેવી રીતે
મૂળભૂત રીતે તમે કે પોર્ટ પર જાઓ.

459
00:27:28,720 --> 00:27:33,240
તેથી હું આ રહ્યો જાઓ જાઉં છું
હું AWS પર ચાલી રહ્યો છું છે.

460
00:27:33,240 --> 00:27:37,150
હું 32769 પર જવા માટે જઇ રહ્યો છું.

461
00:27:37,150 --> 00:27:37,650
અરે.

462
00:27:37,650 --> 00:27:40,495

463
00:27:40,495 --> 00:27:41,120
અને અહીં અમે જાઓ.

464
00:27:41,120 --> 00:27:44,550
>> તેથી આ માત્ર ખરેખર છે
બતાવે છે કે વેબ સેવા

465
00:27:44,550 --> 00:27:46,240
જે તે સેવા આપી રહી છે કન્ટેનર.

466
00:27:46,240 --> 00:27:50,450
તેથી જો તમે તે જોઈ શકો છો
કન્ટેનર a9f છે.

467
00:27:50,450 --> 00:27:52,850
અને અહીં આ છે
કન્ટેનર શાળાના નામ.

468
00:27:52,850 --> 00:27:56,550
તેથી જો તમે ગાય્સ કેવી રીતે ઝડપથી જોઈ શકો છો તે
ખરેખર માત્ર ખેંચી હતી પણ

469
00:27:56,550 --> 00:28:00,440
આ કન્ટેનર જમાવવા.

470
00:28:00,440 --> 00:28:05,070
>> હવે આગામી પગલું છે
Dockerfiles તપાસ

471
00:28:05,070 --> 00:28:09,430
અને કેવી રીતે અમે ખરેખર કરી શકો છો
નવી છબીઓ બનાવો.

472
00:28:09,430 --> 00:28:15,250
હું માત્ર ક્લોન વિચાર જાઓ જાઉં છું, એક
Dockerfile અગાઉ પર આધારિત નમૂના

473
00:28:15,250 --> 00:28:17,755
રેખાકૃતિ, અપાચે અને PHP, માટે એક.

474
00:28:17,755 --> 00:28:26,740

475
00:28:26,740 --> 00:28:28,140
આસ્થાપૂર્વક હું મારા રેપો યાદ કરે છે.

476
00:28:28,140 --> 00:28:36,410

477
00:28:36,410 --> 00:28:38,750
>> તેથી હું હમણાં મારા રીપોઝીટરી હોય છે.

478
00:28:38,750 --> 00:28:43,080
અને તમે જોઈ રહ્યા છીએ
આ એક ઘણો ખરેખર.

479
00:28:43,080 --> 00:28:45,110
હું વૃક્ષ સ્થાપિત ન હતી.

480
00:28:45,110 --> 00:28:48,700
>> જેથી મૂળભૂત રીતે તમે તે જોવા માટે જઈ રહ્યાં છો
તમારો સ્રોત કોડ દસ્તાવેજીકરણ આસપાસ

481
00:28:48,700 --> 00:28:51,240
તે છે, અને પછી Dockerfile
કેવી રીતે ખરેખર તે પેકેજ.

482
00:28:51,240 --> 00:28:57,970
તેથી તે માત્ર એક નમૂનો PHP,
કે હેલો CS50 સર્જાતી.

483
00:28:57,970 --> 00:29:01,550
>> હું તેને ચલાવવા માંગો છો, તો,
હું Docker બિલ્ડ કરવું પડશે.

484
00:29:01,550 --> 00:29:03,370
હું તેને પ્રથમ વખત બિલ્ડ છે.

485
00:29:03,370 --> 00:29:12,420
હું તે demo_cs50 નામ જાઉં છું.

486
00:29:12,420 --> 00:29:16,470
અને તમે પણ તે એક ટેગ જરૂર છે.

487
00:29:16,470 --> 00:29:19,802
તેથી તે કોઈ V1 કૉલ દો.

488
00:29:19,802 --> 00:29:21,760
હું અગાઉ વર્ણવેલ તેથી,
હું આજે શું કરી રહ્યો છું

489
00:29:21,760 --> 00:29:26,840
હું ઉપયોગ જવા માટે Docker જણાવું છું છે
that-- ખરેખર, માફ કરશો, મારા ખરાબ.

490
00:29:26,840 --> 00:29:29,450

491
00:29:29,450 --> 00:29:32,500
અમે એક નજર ન હતી
આ Dockerfile જ.

492
00:29:32,500 --> 00:29:39,020
તેથી અહીં માત્ર વસ્તુઓ છે
તેમજ README ફાઈલ index.php

493
00:29:39,020 --> 00:29:39,810
અને Dockerfile.

494
00:29:39,810 --> 00:29:44,600
>> તેથી જો તમે એક દેખાવ પર લઇ જો
આ Dockerfile, તેથી તે છે

495
00:29:44,600 --> 00:29:47,150
ખૂબ સમાન શું
હું અગાઉ વર્ણવ્યા અનુસાર.

496
00:29:47,150 --> 00:29:51,220
તે માત્ર એક ટોળું છે
Docker ચલાવે છે કે પગલાંઓ

497
00:29:51,220 --> 00:29:56,330
કન્ટેનર બનાવવા અને નીચે જબરદસ્ત દ્વારા
અને [? ગણતરી?] તેમને એક ઈમેજમાં.

498
00:29:56,330 --> 00:29:59,570
>> અને મૂળભૂત રીતે તમે આ કરી શકો છો
see-- [અશ્રાવ્ય] તે અહીં

499
00:29:59,570 --> 00:30:04,340
પરંતુ આ સ્થાનિક રેપો છે.

500
00:30:04,340 --> 00:30:06,410
તે જાઓ અને ગ્રેબ index.php રહ્યું છે.

501
00:30:06,410 --> 00:30:10,970
તેથી તે માત્ર સ્રોત કોડ કે
ખરેખર તમારી અરજી ભાગ છે.

502
00:30:10,970 --> 00:30:16,800
આ બધા મૂળભૂત છે
ઓપરેટિંગ સિસ્ટમ પ્લમ્બિંગ,

503
00:30:16,800 --> 00:30:21,460
જમણી પેકેજો મેળવી અને
અપાચે, અને PHP, અને whatnot.

504
00:30:21,460 --> 00:30:26,950
પરંતુ આ વાસ્તવમાં index.php લઈ રહ્યું છે
અને કન્ટેનર માં સંગ્રહવાથી,

505
00:30:26,950 --> 00:30:28,210
છબી માં.

506
00:30:28,210 --> 00:30:33,120
>> તેથી જો તમે આગળ વધો અને ચલાવી રહ્યા હોય તો આ
નીચેના કરવાથી આદેશ,

507
00:30:33,120 --> 00:30:36,155
તે ખરેખર જઈને છે
આ એક બીટ લાગી શકે છે.

508
00:30:36,155 --> 00:30:40,870

509
00:30:40,870 --> 00:30:42,455
આસ્થાપૂર્વક તે ખૂબ લાંબુ લેવા નથી.

510
00:30:42,455 --> 00:30:45,129

511
00:30:45,129 --> 00:30:46,170
તેથી જો તમે પગલાંઓ જોઈ શકો છો.

512
00:30:46,170 --> 00:30:49,320
અને હું જવા માટે પ્રોત્સાહિત કરીએ છીએ
ઘરે પાછા આજે અને તે પ્રયાસ કરો.

513
00:30:49,320 --> 00:30:51,280
અને Mano વર્ણન કરશે
બરાબર તમે કેવી રીતે તે કરવા.

514
00:30:51,280 --> 00:30:57,810
પરંતુ તે બરાબર જોવા માટે ખરેખર મહાન છે
શું પડદા પાછળ ચાલી રહ્યું છે.

515
00:30:57,810 --> 00:31:02,420
પરંતુ તે બિલ્ડ હાસ્યજનક સરળ છે
છબીઓ Docker મદદથી તેમને જમાવવા અને.

516
00:31:02,420 --> 00:31:12,170

517
00:31:12,170 --> 00:31:14,050
>> તે થોડી લેતી છે
હું અપેક્ષા કરતાં લાંબા સમય સુધી.

518
00:31:14,050 --> 00:31:29,085

519
00:31:29,085 --> 00:31:32,690
>> માતાનો પાસે ઠંડી થાય છે જ્યારે તે જોવા દો.

520
00:31:32,690 --> 00:31:36,260
તમે તે પગલાંઓ, દરેક જોઈ શકો છો તેથી
આ Dockerfile માં રેખાઓ પ્રતિનિધિત્વ કરે છે.

521
00:31:36,260 --> 00:31:42,570
અને તે છે કે અહીં બતાવે
સફળતાપૂર્વક આ છબી બનાવી છે.

522
00:31:42,570 --> 00:31:46,480
>> હું Docker છબીઓ હોય તો, હું જાઉં છું
હું સ્થાનિક છે કે તમામ ચિત્રો જુઓ.

523
00:31:46,480 --> 00:31:52,160
અને તેમાંથી એક કહેવામાં આવે છે મારા
વપરાશકર્તા નામ, અને ઇમેજ નામ

524
00:31:52,160 --> 00:31:56,050
અને ટેગ representing--
મુખ્યત્વે તે આવૃત્તિ ટેગ છે.

525
00:31:56,050 --> 00:31:58,040
>> તેથી હવે હું ચલાવવા માંગો છો, તો
તે હું Docker આઉટ નથી.

526
00:31:58,040 --> 00:32:06,040

527
00:32:06,040 --> 00:32:14,960
અને હું માત્ર એક -d -P કરવા માંગો છો. V1 કરો.

528
00:32:14,960 --> 00:32:18,500
તેથી હું બે હોય છે કે હવે જોઈ શકો છો
કન્ટેનર, એક ચાલી હું માત્ર

529
00:32:18,500 --> 00:32:21,230
બનાવી અને હેલો
હું છેલ્લા મળી કે Docker છે.

530
00:32:21,230 --> 00:32:24,320
>> અને તમે અહીં જોઈ તે કરી શકો છો
તે એક અલગ પોર્ટ આઈડી.

531
00:32:24,320 --> 00:32:30,710
હું જ IP પર જાઓ, પરંતુ તે સોંપી તેથી જો
એક અલગ port-- આશા છે કે હું ન હતી.

532
00:32:30,710 --> 00:32:33,060
તેથી હવે આ એપ્લિકેશન છે
હું માત્ર તૈનાત છે.

533
00:32:33,060 --> 00:32:35,980

534
00:32:35,980 --> 00:32:43,900
>> હું ફેરફાર કરવા માંગો છો, તો હું
ઝડપથી સ્રોત કોડ ફેરફાર કરી શકો છો

535
00:32:43,900 --> 00:32:49,050
અને નીચે પ્રમાણે કરો.

536
00:32:49,050 --> 00:32:55,170
માતાનો હેલો હાર્વર્ડ કરીએ.

537
00:32:55,170 --> 00:32:57,989
તેથી હવે શું થઈ રહ્યું છે
થાય છે હું છું છે

538
00:32:57,989 --> 00:32:59,905
એક સાથે ટૅગ કરવા જઇ
version-- ઓહ અલગ,

539
00:32:59,905 --> 00:33:03,080
આ તે ટૅગ guy--
એક અલગ આવૃત્તિ છે.

540
00:33:03,080 --> 00:33:05,735
અને તમે જઈ રહ્યાં છો
see-- તમે ગાય્ઝ અપેક્ષા નથી

541
00:33:05,735 --> 00:33:11,020
તે સમય જ જથ્થો લેવા માટે
તે બીજી બીલ્ડ સમય નથી અથવા?

542
00:33:11,020 --> 00:33:14,470
બધા હક છે, અને કોઈને શા માટે ખબર છે?

543
00:33:14,470 --> 00:33:15,020
બોલ.

544
00:33:15,020 --> 00:33:16,350
>> AUDIENCE: [અશ્રાવ્ય]

545
00:33:16,350 --> 00:33:19,830
>> નિકોલા KaBar: તે મૂળભૂત છે અમે
માત્ર પછી પગલા બદલો.

546
00:33:19,830 --> 00:33:23,110
અને તેથી તે વાપરવા માટે ચાલી રહ્યું છે
કેશ તે સ્તરો દરેક ઉપયોગ કરે છે અને.

547
00:33:23,110 --> 00:33:27,080
અને તે ખરેખર કેટલાક છે
Docker ના કિલર લક્ષણો

548
00:33:27,080 --> 00:33:32,930
તે ખરેખર ઉપયોગ કરે છે કેવી રીતે છે
અને reuses પર લઈ

549
00:33:32,930 --> 00:33:36,950
એ જ માટે તમારા ડિસ્ક
માહિતી ચોક્કસ ટુકડાઓ.

550
00:33:36,950 --> 00:33:40,700
>> અમે એક જ વસ્તુ હોય તો,
તે માત્ર એક દંપતિ સેકન્ડ લીધો હતો.

551
00:33:40,700 --> 00:33:48,860
અમે તેથી હવે redeploy-- કરવા માંગો છો
હું ત્રણ કન્ટેનર હોવી જોઇએ.

552
00:33:48,860 --> 00:33:56,160
પરંતુ આ એક કરવામાં આવી રહી છે
the-- સાત પર સેવા આપી હતી.

553
00:33:56,160 --> 00:33:58,860
તેથી હવે તે ત્રીજા કન્ટેનર છે.

554
00:33:58,860 --> 00:34:02,580
દરેક વ્યક્તિને સમજી
શું હું હમણાં જ અહીં કર્યું?

555
00:34:02,580 --> 00:34:06,320
>> તેથી હવે તમે આ શેર કરવા માંગો છો તો
તમારા મિત્રો સાથે વાસ્તવિક ઝડપી કન્ટેનર,

556
00:34:06,320 --> 00:34:14,840
તમે માત્ર Docker દબાણ કરી શકો છો
આસ્થાપૂર્વક, કન્ટેનર શાળાના નામ.

557
00:34:14,840 --> 00:34:20,130
તેથી હવે તે તેને દબાણ કરવા જઈ રહ્યું છે
રહ્યો હું અહીં સાઇન ઇન નથી છું.

558
00:34:20,130 --> 00:34:33,511

559
00:34:33,511 --> 00:34:34,219
એ માટે દિલગીર છું.

560
00:34:34,219 --> 00:34:39,219
પરંતુ હવે હું આ મુશ્કેલીનિવારણ નથી જતા છું.

561
00:34:39,219 --> 00:34:42,780
પરંતુ મૂળભૂત રીતે કે એક આદેશ
માત્ર તે દબાણ રહ્યું છે.

562
00:34:42,780 --> 00:34:45,670
અને તમે કરવાનો પ્રયત્ન કરવા માટે જઈ રહ્યાં છો
તમે Docker હબ પર જાઓ, તો તેને જોવા

563
00:34:45,670 --> 00:34:48,587
અને તમે, તમે છો પ્રવેશ
તેને જોવા માટે સમર્થ હોઈ ચાલે.

564
00:34:48,587 --> 00:34:50,420
અને પછી તમે ફક્ત કરી શકો છો
રહ્યું છે રહેલી વ્યકિત નિર્દેશ

565
00:34:50,420 --> 00:34:52,750
જાઓ અને તેને ખેંચી છે કે જે ઇમેજ વાપરવા માટે.

566
00:34:52,750 --> 00:34:55,460
અને તેઓ તેને વાપરી શકો છો.

567
00:34:55,460 --> 00:34:57,760
>> કે સાથે, આસ્થાપૂર્વક
હું પ્રકારની દર્શાવ્યું

568
00:34:57,760 --> 00:35:01,230
કેવી રીતે સરળ Docker સાથે કામ કરે છે.

569
00:35:01,230 --> 00:35:06,610
અને હું માત્ર જાઉં છું
પાછા Mano આપો.

570
00:35:06,610 --> 00:35:11,760
અને તે અહીં તેને લેવા જઈ રહ્યું છે.

571
00:35:11,760 --> 00:35:13,990
>> Mano ગુણ: બધા અધિકાર
આભાર, આભાર નિકો.

572
00:35:13,990 --> 00:35:18,700

573
00:35:18,700 --> 00:35:20,614
તો શું?

574
00:35:20,614 --> 00:35:24,410
તેથી એક વસ્તુઓ હું
કરવા માગતો મૂકવામાં આવે છે

575
00:35:24,410 --> 00:35:28,820
શા માટે આ એક important-- છે
શા માટે Docker અને શા માટે

576
00:35:28,820 --> 00:35:33,000
કન્ટેનર એક જેમ કે છે
મહત્વપૂર્ણ નવા વિકાસ,

577
00:35:33,000 --> 00:35:36,890
ખરેખર સોફ્ટવેર કરવાનું એક નવી રીત.

578
00:35:36,890 --> 00:35:41,300
>> હું શું તે પહેલાં, હું જાઉં છું
માત્ર થોડા આંકડા રજૂ કરે છે.

579
00:35:41,300 --> 00:35:42,790
હું આ બધી વાંચી નથી જઈ રહ્યો છું.

580
00:35:42,790 --> 00:35:52,540
પરંતુ આ તમે કેવી રીતે વિશે ઘણું બતાવે
લોકપ્રિય આ સમુદાય છે.

581
00:35:52,540 --> 00:35:56,310
મુખ્ય Docker ટેકનોલોજી
ઓપન સોર્સ છે.

582
00:35:56,310 --> 00:36:03,560
જેથી Docker એન્જિન કંપોઝ છે,
જીગરી, અન્ય સામગ્રી એક ટોળું

583
00:36:03,560 --> 00:36:05,210
બધા ખુલ્લા સ્ત્રોત છે.

584
00:36:05,210 --> 00:36:10,590
અને અમે હોય છે, શું હું કર્યું
1,300 ફાળો કહે છે.

585
00:36:10,590 --> 00:36:15,630
તમે જુઓ તો તમે હવે જોઈ રહ્યાં છો
નોકરી મુખ સંખ્યા, છેલ્લા સમય

586
00:36:15,630 --> 00:36:19,640
અમે તે વિશે 43,000 નોકરી હતી જોવામાં
મુખ ખાસ ઉલ્લેખ

587
00:36:19,640 --> 00:36:22,230
Docker સાથે પારિવારિકતા.

588
00:36:22,230 --> 00:36:26,450
છબીઓ લાખો સેંકડો હોય
Docker હબ પરથી ડાઉનલોડ કરવામાં આવી છે.

589
00:36:26,450 --> 00:36:31,870
અને સારી રીતે, વધુ મોટા આંકડા.

590
00:36:31,870 --> 00:36:34,770
>> વિચિત્ર હોય તેવા લોકો માટે, તે
મૂળ Python માં લખવામાં આવ્યું હતું

591
00:36:34,770 --> 00:36:37,730
અને પછી જાઓ માં ફરીથી લખી.

592
00:36:37,730 --> 00:36:40,320
અને તે માત્ર રહી છે
તે માત્ર સ્ત્રોત ખોલવા

593
00:36:40,320 --> 00:36:44,950
લગભગ 2 અને 1/2 વર્ષ માટે પ્રકાશિત કરવામાં આવી,
જે 2 અને 1/2 વર્ષ અર્થ થાય છે,

594
00:36:44,950 --> 00:36:48,020
અમે એક જબરદસ્ત જથ્થો જોઇ
વૃદ્ધિ અને મહત્વ

595
00:36:48,020 --> 00:36:50,190
સમુદાયમાં આ.

596
00:36:50,190 --> 00:36:52,400
અને તેથી હું વાત કરવા માંગો છો
શા માટે વિશે થોડુંક.

597
00:36:52,400 --> 00:36:54,940

598
00:36:54,940 --> 00:36:59,880
>> તેથી માત્ર કેટલાક પુનરુક્તિ કરવી
નિકો કી પોઇન્ટ Docker ઝડપી છે.

599
00:36:59,880 --> 00:37:00,630
તે પોર્ટેબલ છે.

600
00:37:00,630 --> 00:37:02,500
તે પ્રજનન છે.

601
00:37:02,500 --> 00:37:06,130
અને તે પ્રમાણભૂત પર્યાવરણ સુયોજિત કરે છે.

602
00:37:06,130 --> 00:37:13,370
>> અને આ મારા ખરાબ છે what--
નિર્મૂળ Monoliths slide-- શું

603
00:37:13,370 --> 00:37:17,990
તે લોકો શું મદદ છે, જે
સોફ્ટવેર ઉદ્યોગ ઘણો

604
00:37:17,990 --> 00:37:21,400
માં કરવાનું શરૂ કર્યું
2000 ના પ્રારંભમાં, આગળ વધી રહી છે

605
00:37:21,400 --> 00:37:24,200
આ પત્થરના થી
એક કાર્યક્રમો

606
00:37:24,200 --> 00:37:28,590
દરેક નિર્ભરતા કરી હતી, જ્યાં
સમગ્ર એપ્લિકેશન હતી તે પહેલાં પરીક્ષણ

607
00:37:28,590 --> 00:37:31,280
, જમાવટ કરી જે
એક વેબસાઇટ અર્થ કરી શકે છે

608
00:37:31,280 --> 00:37:36,240
માત્ર એક જ વાર તૈનાત મળ્યો
દર ત્રણ મહિના, અથવા વધુ,

609
00:37:36,240 --> 00:37:42,650
વધુ સેવા કરવા માટે
લક્ષી આર્કિટેક્ચર

610
00:37:42,650 --> 00:37:46,090
અથવા componentized વિવિધ પ્રકાર
અરજી આર્કીટેક્ચર.

611
00:37:46,090 --> 00:37:48,610
અને તેથી આ માટે પરવાનગી આપે છે
આર્કિટેક્ચર કાઇન્ડ

612
00:37:48,610 --> 00:37:52,250
તે લાભ લેવા
Docker આ ત્રણ ચલાવવા માટે

613
00:37:52,250 --> 00:37:58,450
વિકાસ મુખ્ય વિસ્તારો, જે
વિકાસ તમારી વાસ્તવિક કોડ લખી છે,

614
00:37:58,450 --> 00:38:00,140
તમારો કોડ પરીક્ષણ, અને તે જમાવવા.

615
00:38:00,140 --> 00:38:03,000

616
00:38:03,000 --> 00:38:05,420
>> તેથી આ શા માટે અગત્યનું છે?

617
00:38:05,420 --> 00:38:09,920
તમે દો a-- છો, તો મને એક ઉદાહરણ આપે છે.

618
00:38:09,920 --> 00:38:13,600
તમે વેબસાઇટ હોય તો
ઉપકરણ ડેવલપર, તમે છો

619
00:38:13,600 --> 00:38:19,020
આ પર આધારિત છે કે જે એક વેબસાઇટ વિકાસ
ડેવિડ અહીં ઉત્પાદન કે ડેટાબેઝ.

620
00:38:19,020 --> 00:38:20,490
માફ કરશો ડેવિડ, હું તમને મિસરમાંથી બહાર ફોન કરું છું.

621
00:38:20,490 --> 00:38:22,984

622
00:38:22,984 --> 00:38:24,900
તમે જમાવવા માગતા હતા
સમગ્ર બાબત, તમે કરશો

623
00:38:24,900 --> 00:38:28,870
પરંપરાગત હેઠળ રાહ જોવી
પત્થરના સોફ્ટવેર વિકાસ

624
00:38:28,870 --> 00:38:32,710
પર્યાવરણ, તમે રાહ જોવી છો
તેમણે ડેટાબેઝ સાથે કરવામાં આવી હતી ત્યાં સુધી

625
00:38:32,710 --> 00:38:36,030
તમે ખરેખર કરી શકે તે પહેલાં
તમારી વેબસાઇટ કોઈપણ ફેરફારો.

626
00:38:36,030 --> 00:38:40,900
તમે પુનઃ નિમણૂક હોય તો
આવું કરવા માટે સમગ્ર અરજી.

627
00:38:40,900 --> 00:38:45,490
>> અને શું Docker મદદ કરે છે તમે શું દરેક છે
વિવિધ ઘટકો પર કામ વ્યક્તિ

628
00:38:45,490 --> 00:38:52,990
તરીકે તેઓ જાઓ અને માત્ર બનાવે છે, તેમને સુધારવા
ઇન્ટરફેસો જ રહે છે તેની ખાતરી કરો.

629
00:38:52,990 --> 00:38:56,350
તેથી તે શું કર્યું છે
તે લોકો ખસેડાયેલો રહ્યું છે

630
00:38:56,350 --> 00:39:03,950
આ મોટા પાયે પત્થરના કરવાથી
architected સોફ્ટવેર કે

631
00:39:03,950 --> 00:39:07,610
સતત દર મહિને તૈનાત
સંકલન અને સતત વિકાસ

632
00:39:07,610 --> 00:39:08,490
પર્યાવરણ.

633
00:39:08,490 --> 00:39:12,580
>> હવે આ Docker માટે અનન્ય નથી
પરંતુ Docker, તેથી તે ખૂબ સરળ બનાવે છે

634
00:39:12,580 --> 00:39:16,620
જે તમે મૂળભૂત છો એનો અર્થ એ થાય
સતત જમાવવા.

635
00:39:16,620 --> 00:39:20,690
અમે છે કે સાહસો વાત
જાહેર સામનો કાર્યક્રમો જમાવવા

636
00:39:20,690 --> 00:39:30,180
વખત એક દિવસ, કારણ કે હજારો
તેઓ માત્ર બનાવવા કિંમત જુઓ

637
00:39:30,180 --> 00:39:33,740
નાના ફેરફારો, અને લાંબા સમય સુધી
તે પરીક્ષણો મારફતે ચાલે છે,

638
00:39:33,740 --> 00:39:35,900
તે ઉત્પાદન માં બહાર જાય છે ભાડા.

639
00:39:35,900 --> 00:39:41,890
નિકો હંમેશા મને કહી હતી
અગાઉ તે ઘણા પર્યાવરણોમાં,

640
00:39:41,890 --> 00:39:46,580
એક પ્રમાણભૂત જીવન ચક્ર
કન્ટેનર સેકન્ડોમાં મપાય છે,

641
00:39:46,580 --> 00:39:50,460
વર્ચ્યુઅલ મશીન, જ્યારે
મહિના માપવામાં આવી શકે છે.

642
00:39:50,460 --> 00:39:54,590

643
00:39:54,590 --> 00:39:58,690
>> હું થોડો લેવા માગતા હતા
હું કારણ કે અહીં ચાલુ

644
00:39:58,690 --> 00:40:00,170
એક શૈક્ષણિક સંસ્થા છે.

645
00:40:00,170 --> 00:40:06,670
હું કેવી રીતે એક ઉદાહરણ આપવા માગે છે
આ એક શૈક્ષણિક સંશોધન કામ કરે છે

646
00:40:06,670 --> 00:40:07,670
પરિસ્થિતિ.

647
00:40:07,670 --> 00:40:10,930
તેથી એક સંસ્થા છે
કહેવાય bioboxes.

648
00:40:10,930 --> 00:40:15,450
Bioboxes ડીએનએ કરે
સંશોધકો માટે વિશ્લેષણ.

649
00:40:15,450 --> 00:40:22,029
>> હવે તેઓ શું મળી હતી કે જ્યારે
એક researcher-- અને આ નથી

650
00:40:22,029 --> 00:40:24,070
કોઇ ખાસ ની ખામી
researcher-- પરંતુ જ્યારે

651
00:40:24,070 --> 00:40:31,240
જમાવટ સંશોધક
અલ્ગોરિધમનો વિશ્લેષણ કરવા માટે,

652
00:40:31,240 --> 00:40:36,670
ચોક્કસ રીતે, ડીએનએ નમૂના,
તેઓ સોફ્ટવેર લખી શકે છે,

653
00:40:36,670 --> 00:40:39,980
કદાચ, કે પ્રકાશિત
બીજે ક્યાંક GitHub અથવા,

654
00:40:39,980 --> 00:40:42,680
અને પછી તેઓ કરવામાં આવી હતી.

655
00:40:42,680 --> 00:40:47,440
>> વેલ સમસ્યા હતી તે
જરૂરી પ્રજનન ન હતી.

656
00:40:47,440 --> 00:40:51,610
ક્રમમાં કારણ
સોફ્ટવેર સમજે છે,

657
00:40:51,610 --> 00:40:54,830
તેઓ માટે સુયોજિત કરવામાં આવશે
ચોક્કસ વિકાસ પર્યાવરણ

658
00:40:54,830 --> 00:41:00,460
કે સંશોધક સામાન્ય રીતે વપરાય છે કે જે
તેમના લેપટોપ, અથવા સર્વર, અથવા માહિતી

659
00:41:00,460 --> 00:41:04,280
તેઓ ઉપયોગ કરતા હતા કે કેન્દ્ર.

660
00:41:04,280 --> 00:41:11,530
અને પરિણામે, તે ખૂબ જ મુશ્કેલ હતું
સંશોધન પરિણામો જ્યારે પ્રજનન

661
00:41:11,530 --> 00:41:16,910
ડીએનએ નમૂનાઓ વિશ્લેષણ જોવા માટે
incidence-- જેવી વસ્તુઓ પર

662
00:41:16,910 --> 00:41:23,830
હૃદય હુમલા ભારણ તુલના
હાજર હોવા ચોક્કસ જનીનો પર આધારિત છે,

663
00:41:23,830 --> 00:41:28,900
હમણાં પૂરતું, અથવા કેન્સર જોખમ, અથવા
વસ્તુઓ અન્ય પ્રકારના કોઈપણ.

664
00:41:28,900 --> 00:41:33,900
>> તેથી તેઓ શું કર્યું બદલે હતી
તેઓ કન્ટેનર બનાવવાનું શરૂ.

665
00:41:33,900 --> 00:41:39,380
અને તમે bioboxes.org જઈ શકે છે,
તે એક મહાન સંસ્થા છે.

666
00:41:39,380 --> 00:41:43,900
અને શું તેઓ શું તેઓ ઉત્પાદન છે
કન્ટેનર સંશોધન પર આધારિત છે.

667
00:41:43,900 --> 00:41:46,840
અને કોઇની મોકલે પછી જ્યારે
તેમના નમૂના, તેઓ તેને ચલાવી શકો છો.

668
00:41:46,840 --> 00:41:52,770
અને તે બધા પર્યાવરણ છે
કે અલ્ગોરિધમનો ચલાવવા માટે જરૂરી

669
00:41:52,770 --> 00:41:55,370
અને પરિણામો ઉત્પન્ન કરે છે.

670
00:41:55,370 --> 00:41:58,250
અને તેઓ છો કે જે શોધવામાં કરી રહ્યાં છો
વધુ શક્યતા છે અને ખૂબ

671
00:41:58,250 --> 00:42:01,300
વધુ ઝડપથી સક્ષમ
લોકો માટે પરિણામો આવો.

672
00:42:01,300 --> 00:42:06,860
>> અને હકીકતમાં, લોકો શું કરી રહ્યા છે
ડીએનએ પર તેમના પોતાના વિશ્લેષણ ચાલી રહ્યું છે,

673
00:42:06,860 --> 00:42:11,220
bioboxes માં મોકલવા કે, અને
પછી biobox માત્ર માહિતી લે છે,

674
00:42:11,220 --> 00:42:15,350
વિવિધ સામે તે ચાલે છે
વિવિધ કન્ટેનર

675
00:42:15,350 --> 00:42:19,030
વિવિધ પરિણામો જોવા માટે
વિવિધ સંશોધન પર આધારિત છે.

676
00:42:19,030 --> 00:42:21,860
તેથી તે ખૂબ જ શક્તિશાળી છે
માર્ગ કે જેમાં સંશોધકો માં

677
00:42:21,860 --> 00:42:28,070
પરવાનગી આપે છે કે સિંગલ ઇન્સ્ટન્સ કરી શકો છો
અન્ય લોકો પ્રયાસ કરો અને પ્રજનન

678
00:42:28,070 --> 00:42:28,650
પરીણામ.

679
00:42:28,650 --> 00:42:31,710

680
00:42:31,710 --> 00:42:34,360
>> તેથી તમે કેવી રીતે પ્રારંભ કરી શકું?

681
00:42:34,360 --> 00:42:37,950

682
00:42:37,950 --> 00:42:39,800
અમે સારી રીતે Linux પર આધારભૂત છે.

683
00:42:39,800 --> 00:42:43,070
તમે સ્થાપિત કરવા માંગો છો, તો
Linux પર કંઈપણ

684
00:42:43,070 --> 00:42:45,620
તમે તમારા પ્રમાણભૂત ઉપયોગ
પેકેજ વ્યવસ્થાપક સ્થાપિત કરવા માટે.

685
00:42:45,620 --> 00:42:47,600
તમે ડેબિયન ઉપયોગ કરી રહ્યાં છો, તો તે તત્પર વિચાર છે.

686
00:42:47,600 --> 00:42:50,500
CentOS yum છે.

687
00:42:50,500 --> 00:42:53,500
Fedora એ Red Hat છે
rpm-- હું યાદ નથી.

688
00:42:53,500 --> 00:42:56,070
કોઈપણ રીતે, તે બધા ત્યાં છે.

689
00:42:56,070 --> 00:42:59,610
અમે એક મોટી વિવિધ આધાર આપે છે
Linux વિતરણો છે.

690
00:42:59,610 --> 00:43:01,150
તમે તે તપાસી શકો છો.

691
00:43:01,150 --> 00:43:06,370
>> અમે પણ વિકલ્પો હોય છે, જેથી તમે
મેક અથવા વિન્ડોઝ પર ચાલે છે.

692
00:43:06,370 --> 00:43:10,670
હવે નિકો અગાઉ ઉલ્લેખ કર્યો છે કે
તે માત્ર Linux પર ટેકો હતો.

693
00:43:10,670 --> 00:43:18,180
તે છે, કારણ કે સાચું છે
એક Linux કર્નલ જરૂર છે.

694
00:43:18,180 --> 00:43:20,540
પરંતુ, તમે વર્ચ્યુઅલ મશીન માં ચલાવી શકો છો.

695
00:43:20,540 --> 00:43:25,290
અને શું Docker શોધો
તમે ડાઉનલોડ કરી શકો છો, કે જે કરે છે

696
00:43:25,290 --> 00:43:27,610
તે કે જે તમને વર્ચ્યુઅલ મશીન આપે છે.

697
00:43:27,610 --> 00:43:37,260
>> તેથી માત્ર એક ઝડપી 48
બીજું, મને લાગે છે, ડાઉનલોડ કરો.

698
00:43:37,260 --> 00:43:40,670
તમે માત્ર Docker પર શોધ
શોધો, મેક પર ડાઉનલોડ

699
00:43:40,670 --> 00:43:43,910
અને આ ભાગ છે
અલબત્ત કારણ કે જે ઝડપમાં વધારો

700
00:43:43,910 --> 00:43:47,620
ડાઉનલોડ સંકેત જોવા માંગે છે?

701
00:43:47,620 --> 00:43:54,190
ધોરણ મેક સ્થાપન,
અને પછી તમે છો

702
00:43:54,190 --> 00:43:59,795
જેઈ તેમના પાસવર્ડ મૂકવામાં જોવા માટે જઈ રહી છે.

703
00:43:59,795 --> 00:44:00,670
તે ખૂબ જ ઉત્તેજક છે.

704
00:44:00,670 --> 00:44:03,510

705
00:44:03,510 --> 00:44:06,230
અને પછી તે સ્થાપિત
સાધનો સંપૂર્ણ જથ્થો.

706
00:44:06,230 --> 00:44:10,010
અને ખાસ કરીને તે કરશે
આદેશ વાક્ય સ્થાપિત કરો.

707
00:44:10,010 --> 00:44:14,220
અને પછી તમે જોઈ શકે
જેઈ તેમના છબીઓ પરીક્ષણ.

708
00:44:14,220 --> 00:44:19,050

709
00:44:19,050 --> 00:44:22,640
>> અને તે પછી આ પર આધારિત છે,
તમે કે YouTube જોઈ શકે છે

710
00:44:22,640 --> 00:44:27,420
નિકો રસ છે કે વિચારે છે
સ્ટાર વોર્સ, જીમી Kimmel શો,

711
00:44:27,420 --> 00:44:29,020
અને હું એલેન લાગે છે.

712
00:44:29,020 --> 00:44:34,130
હું છેલ્લા એક છે કે જે લાગે છે
એક એલેન શો એક ક્લિપ.

713
00:44:34,130 --> 00:44:37,760
>> તેથી Docker શોધો છતાં આવે છે
માત્ર Docker મશીન કરતાં વધુ છે.

714
00:44:37,760 --> 00:44:39,840
તેથી Docker મશીન છે
મદદ કરે છે કે વસ્તુ

715
00:44:39,840 --> 00:44:43,710
તમે વર્ચ્યુઅલ સુયોજિત
તમારા Windows પર મશીન

716
00:44:43,710 --> 00:44:52,080
અથવા તમારા Windows બોક્સ અથવા તમારા મેક Mac--
box-- અને તમે બચાવ કરવા મદદ કરે છે,

717
00:44:52,080 --> 00:44:54,040
>> પરંતુ તે પણ સાથે આવે છે
જીગરી અને કંપોઝ,

718
00:44:54,040 --> 00:45:00,840
તમે મોટા કરવા માટે મદદ કરવા માટે રચાયેલ છે
તમારી અરજી પાયે ડિપ્લોયમેન્ટ કરે છે.

719
00:45:00,840 --> 00:45:04,000
તમે મેનેજ કરવા માંગો છો તો
ગાંઠો ક્લસ્ટર્સ,

720
00:45:04,000 --> 00:45:08,450
કન્ટેનર ક્લસ્ટરો કંપોઝ અને
સ્વોર્મ તે વિશે જવા માટે માર્ગ છે.

721
00:45:08,450 --> 00:45:11,430
>> અને અલબત્ત તે સાથે આવે છે
Docker એન્જિન અને Kitematic,

722
00:45:11,430 --> 00:45:13,250
જે આ ડેસ્કટોપ GUI છે.

723
00:45:13,250 --> 00:45:17,060
હું પણ Docker રજીસ્ટ્રી ઉલ્લેખ કરીશું
શોધો સમાયેલ નથી જે,

724
00:45:17,060 --> 00:45:23,150
પરંતુ તે તમને તમારા પોતાના ચલાવવા માટે એક માર્ગ છે
Docker જેવા Docker છબીઓ રજીસ્ટ્રાર

725
00:45:23,150 --> 00:45:28,970
હબ છે, પરંતુ તમે પણ માત્ર ઉપયોગ કરી શકો છો
તે કરવા માટે એક માર્ગ તરીકે Docker હબ.

726
00:45:28,970 --> 00:45:32,955
>> અને, પ્લોટ ટ્વિસ્ટ, તમે જોઈ રહ્યાં છો
તે એક કન્ટેનર માં ચાલી રહ્યું છે.

727
00:45:32,955 --> 00:45:34,830
અને તે આપણે રહ્યાં છો કેવી રીતે
અમારા સ્લાઇડ્સ વિતરણ.

728
00:45:34,830 --> 00:45:38,610
આ સમગ્ર પ્રસ્તુતિ છે
ખરેખર એક HTML સ્લાઇડ તૂતક.

729
00:45:38,610 --> 00:45:43,170
અને તે ચાલી રહ્યું છે
તમે by-- મેળવી શકો છો કે જે કન્ટેનર,

730
00:45:43,170 --> 00:45:45,596
>> નિકોલા KaBar: હા, તો તે છે
મારા મેક્સ પર સંપૂર્ણ સમય ચાલી રહ્યું છે.

731
00:45:45,596 --> 00:45:47,540
અને હું તે પ્રસ્તુત કરી રહ્યો છું.

732
00:45:47,540 --> 00:45:50,910
અને તમે માત્ર પછી Docker કરી
તમે તમારા સાધન પેટી સ્થાપિત કરો.

733
00:45:50,910 --> 00:45:57,340
તમે માત્ર એક Docker રન કરી શકો છો
અને તે મેળવવા માટે, અને સ્લાઇડ્સ ઉપયોગ કરે છે.

734
00:45:57,340 --> 00:45:58,830
>> Mano ગુણ: અને તે છે.

735
00:45:58,830 --> 00:46:02,160
તેથી અમે આગામી માટે તમે બધા આભાર.

736
00:46:02,160 --> 00:46:03,990
અને અમે પ્રશ્નો જવાબ ખુશ છો.

737
00:46:03,990 --> 00:46:07,810
હું કોઈની પહેલાં ઉલ્લેખ કરીશું
નહીં ત્યાં ટી-શર્ટ છે.

738
00:46:07,810 --> 00:46:10,940
માફ કરશો કોઇ જોઈ રહ્યાં છે
Livestream અથવા વિડિઓ પર આ,

739
00:46:10,940 --> 00:46:12,820
પરંતુ અમે ત્યાં Docker ટી શર્ટ છે.

740
00:46:12,820 --> 00:46:16,250
અને અમે Docker વિદ્યાર્થીઓ ખબર છે,
અને મારા અનુભવ,

741
00:46:16,250 --> 00:46:18,940
પણ, મફત કપડાં જેવી પ્રોફેસરો.

742
00:46:18,940 --> 00:46:22,490
>> જેથી બહાર આવતા માટે તમે બધા આભાર.

743
00:46:22,490 --> 00:46:27,050
અને ટ્વિટર પર અમને અનુસરો
તમે કરવા માંગો છો, અથવા ન કરો તો.

744
00:46:27,050 --> 00:46:27,910
હું પડી નથી.

745
00:46:27,910 --> 00:46:29,430
પણ Twitter પર Docker અનુસરો.

746
00:46:29,430 --> 00:46:31,890
તે પણ રસપ્રદ છે.

747
00:46:31,890 --> 00:46:32,990
અને પછી તે છે.

748
00:46:32,990 --> 00:46:33,490
Docker.com.

749
00:46:33,490 --> 00:46:35,410
આભાર.

750
00:46:35,410 --> 00:46:39,360
>> [વધાવી]

751
00:46:39,360 --> 00:46:41,625