>> [მუსიკის დაკვრა]
DAVID Malan ყველა უფლება.
დიდი მადლობა მობრძანებისთვის.
ეს არის CS50 სემინარი თემაზე Docker, რომელიც ტექნოლოგია, რომელიც ჩვენ თვითონ და CS50
გამოყენება დაიწყო გარკვეული დრო.
ასე რომ, ჩემი სახელი არის დავით Malan, მე ასწავლიან, ჰარვარდის შესავალი
კომპიუტერული მეცნიერების.
საკმაოდ რამდენიმე წლის განმავლობაში, ჩვენ უკვე ვაძლევთ
ჩამოსატვირთი კლიენტის მხარეს ვირტუალური მანქანები
შესახებ, რომელიც მათ ამის გაკეთება და მათი პრობლემები კომპლექტი.
რომ ჩვენ ახლა გადავიდა რომ Cloud გარემო
რომ რეალურად იყენებს ამ ტექნოლოგიას მოუწოდა Docker, ისეთი, რომ ყველა CS50
სტუდენტები გაუჩნდა საკუთარი Docker კონტეინერები
რომ თქვენ მალე მოვისმინოთ ყველაფერი.
>> უფრო მეტიც, CS50 სერვერზე მხარე კასეტური, მრავალი წლის განმავლობაში
ჩვენ გამოყენებით Amazon- ის Cloud სერვერზე.
ჩვენ გავრბოდით ინდივიდუალური ვირტუალური მანქანები.
ეს ძალიან, ჩვენ დავიწყეთ გადასვლას ეს რამ მოუწოდა Docker კონტეინერები
ისე, რომ ყველა ჩვენი პროგრამა ახლა კარგად იზოლირებული ერთმანეთისგან.
ასე რომ, რომ და სხვა, ნება მიბოძეთ წარმოგიდგინოთ ჩვენი მეგობრები, ნიკო და Mano,
საწყისი Docker თავად.
NICOLA KABAR: მადლობა, დავით.
გამარჯობა ყველას.
ჩემი სახელი არის ნიკო და ეს არის Mano.
ჩვენ ეხლა Docker.
ჩვენ ვაპირებთ, რომ იყოს საუბარი ამაზე გაწვდით ბიჭები intro, რომ Docker,
და იმედია, დასასრულს ამ განხილვა შეგიძლიათ გააცნობიეროს
რამდენად შეგიძლიათ გამოიყენოთ ექიმს, რათა ოქსალატი თქვენი განაცხადი განვითარების
და განლაგებას.
>> ასე რომ, ჩვენ ვაპირებთ დავიწყოთ off რეალური სწრაფი ზოგიერთი ინფორმაცია.
აღწერეთ რა Docker არის ყველაფერი.
როგორ მუშაობს?
როგორ არის ეს architected?
მე უნდა აკეთებს ზოგიერთი demos.
და Mano იქნება აღწერილია, თუ როგორ შეგიძლიათ გამოიყენოთ Docker
და გაწვდით კონკრეტული ნაბიჯები როგორ შეგიძლიათ დავიწყოთ.
>> მე ვაფასებ თუ ბიჭები გამართავს off თქვენი კითხვები დასასრულს.
ასე რომ, მე შეიძლება მიმართავენ იმ შეკითხვები მასშტაბით პრეზენტაციაზე.
ამიტომ, ჩვენ დავტოვებთ გარკვეული დრო დასასრულს შეკითხვებზე.
>> ასე რომ, მხოლოდ რეალური სწრაფი, რომელსაც აქვს რეალურად მუშაობდა Docker,
ისევე როგორც ითამაშა ეს?
გასაოცარია.
ზემოთ.
შესანიშნავი.
ასე რომ, მე ვაპირებ, რომ დაიწყოს ზოგიერთ ისტორია.
ასე რომ უკან 90-იან წლებში და 2000-იან წლებში, ძირითადად,
როგორც ვებ დეველოპერები, app დეველოპერები, როდესაც ისინი წავიდნენ განათავსოს განცხადება
ეს იყო მიბმული შიშველი მეტალის.
ეს იყო ერთ სერვერზე.
ეს იყო ერთ-ერთი განაცხადი.
>> ტრადიციულად, მაგალითად, იქნება, როგორიც LAMP დასტის,
სადაც თქვენ რეალურად ჰქონდა ზრდიან აუზი რესურსები.
CPU, მეხსიერება, დისკზე, ქსელი, დაყენების ოპერაციული სისტემა თავზე რომ.
თუ თქვენ ემსახურება რაღაც, თუ თქვენ, ფაქტობრივად, რომელსაც სერვერზე,
თქვენ უნდა რაღაც Apache ემსახურება მას.
>> თუ თქვენი განცხადება საჭიროებს მონაცემთა ბაზა, backhand,
თქვენ დააყენოთ რაღაც როგორიცაა MySQL, და ასე შემდეგ.
და თუ თქვენ უნდა პერსპექტივაში დრო, PHPs და PHP Python მუშაობა იყო.
ასე რომ, ჩვენ რეალურად ჰქონდა მიიღოს იმ ნაბიჯებს, რათა
თქვენი განაცხადი და გაშვებული.
>> თუ თქვენ საჭიროა უფრო compute ძალა, თქვენ ძირითადად იძულებული თქვენი Ops ბიჭი
ან gal წასვლა და თაროს up ახალი ნაჭერი აპარატურა, დააკავშირებს მას,
და თქვენ უნდა გავიმეოროთ ის პროცესები ისევ და ისევ.
ასე რომ, ეს პროცესი იყო შედარებით ძვირია.
ნამდვილად ძალიან ნელი.
>> ეს იყო არაეფექტური.
და ბევრი შემთხვევა, თქვენი ტექნიკა გამოუყენებელი.
ასე რომ, 90-იანი წლების და 2000-იან წლებში, ტექნიკა ვირტუალიზაციის წააწყდნენ.
და როგორც ხედავთ აქ სურათი, ძირითადად, რა გააკეთეს
რეფერირებადი აუზი უფასო აპარატურული რესურსების
და სახის ემსახურება იმ ზედა ფენა,
ამ შემთხვევაში, სტუმარი ოპერაციული სისტემა.
>> და მთელი იდეა ვირტუალური მანქანები წააწყდნენ
და რომ ნამდვილად დაეხმარა Cloud კომპიუტერული, როგორც ჩვენ ვიცით დღეს.
ასე რომ, რას ნიშნავდა ეს არის თუ არა შეგიძლიათ გაუშვათ სხვადასხვა VMs, რომელიც
ნიშნავდა მრავალი stacks, მრავალი განცხადება იმავე ფიზიკური მანქანა.
>> ეს ნამდვილად დაეხმარა სიჩქარე განაცხადის განლაგებას.
აუცილებლად ერთად ხარჯები.
თქვენ არ უნდა წავიდეს და გატარება ენერგია, დრო და რესურსები თაროს
მეტი სერვერები მისაღებად უფრო compute.
და სიჩქარე რეალურად შემოტანა იმ რესურსებს up ბევრად უფრო სწრაფად.
შესანიშნავი.
>> ასე რომ, ჩვენ მოგვარდეს მსოფლიოში შიმშილის, არა?
არა, ნამდვილად არ.
ასე რომ, ვირტუალიზაციის, როგორც ეს რეალურად დაეხმარა, მივმართო პრობლემა,
ეს რეალურად გააცნო ბევრი გამოწვევები.
Hypervisor აუცილებლად გააცნო ბევრი სირთულის,
გატარება იმ ფუძემდებლური აუზი რესურსები.
>> ეს მძიმე იმ გაგებით, რომ ადრე თქვენ გვქონია ოპერაციული სისტემა, რომელიც
არის როგორც სამი, ოთხი gigs დისკზე.
ახლა, თუ თქვენ გაქვთ 10 მანქანები ერთ ტექნიკის
თქვენ უნდა გავამრავლოთ, რომ მიერ რაოდენობის მანქანები.
ეს ნამდვილად უფრო ძვირადღირებული გაგებით მაინც
უნდა მიიღოს ლიცენზირების ვირტუალიზაციის ტექნოლოგია
თუ ეს არ არის ღია.
>> მაგრამ, მოდით არ მიიღებს ყველა კრედიტი ვირტუალიზაციის.
იმის გამო, რაც მოხდა, არის ის, რომ იქ ბევრი stacks და უამრავი პროგრამა
ტექნოლოგიების, რომ საშუალება მიეცათ რამდენად სწრაფად თქვენ შეუძლია მიიღოს
რესურსების ერთად Cloud ბუმი.
>> ასე რომ, დღეს ერთი ოთახი ან მომსახურების შეუძლია გამოყენებით ნებისმიერ შემდეგ runtimes
ან ბაზაში.
PHP, Python, MySQL, Redis, whatnot.
ასე რომ, ბევრი სირთულის ამ ნომერი stacks რეალურად ზრდიან
ერთი მომსახურებას.
და ერთად, რომ თქვენ ჰქონდა ბევრი ძირითადი რესურსები და ინფრასტრუქტურა
სახის შესამოწმებლად განათავსოს და ძირითადად მიიღოს პროდუქციის იმ პროგრამები
რომ თქვენ ვითარდება.
>> მით უმეტეს, რომ თქვენი გუნდი უნდა გაიზარდა მომუშავე იმ apps,
არსებობს ბევრი სირთულისა და გამოწვევები
რომლებიც მოიტანა, რათა უზრუნველყოს, რომ cycle-- ძირითადად განცხადება
განვითარების ციკლი, არის რეალურად წარმატებული.
ასე რომ, ის ფაქტი, რომ თქვენი განცხადება მუშაობს ადგილობრივად თქვენს VM
არ იძლევა გარანტიას, რომ თქვენი კოლეგა აპირებს, რომ იგივე შედეგი.
>> და როცა ოპერაციების გუნდი მონაწილეობდა, რაც თქვენ უნდა
და იქ ის წარმოების მასშტაბის, ასევე არ არსებობს გარანტია,
, რომ ეს რეალურად მოხდება.
ასე რომ, ეს ტოვებს ჩვენთვის ნამდვილად big-- ბევრი კითხვის ნიშნები,
ბევრი გამოწვევები რეალურად წინაშე ერთნაირად უკან დღეებში.
და რომ გაგვახსენა გადაზიდვის ინდუსტრიაში.
>> ასე რომ, გადაზიდვის ინდუსტრიის ჰქონდა ბევრი საქონელი,
როგორც ხედავთ, მარცხენა მხარეს.
და მარჯვენა მხარეს, არსებობს ბევრი, ძირითადად,
გზები მოვახდენთ იმ საქონლის.
და რა ხდება, როგორც წყვილი ეგ მოვიდა ერთად და განაცხადა,
ჩვენ უნდა სტანდარტიზაცია, თუ როგორ ჩვენ რეალურად მოვახდენთ იმ საქონლის.
და ბუმი, თქვენ გაქვთ ინტერმოდალური კონტეინერი.
>> ასე რომ, ისინი შეთანხმდნენ, რომ ყველაზე საერთო ზომის კონტეინერი.
როგორ გაუმკლავდეს მათ.
რა ზუსტი მეთოდი თქვენ უნდა ჩატვირთვა მათ და განტვირთავს მათ.
აქედან გამომდინარე, რომ ნამდვილად დაეხმარა გადაზიდვის ინდუსტრიაში.
ახლა 90% -ზე მეტი აქცენტი ტრანსპორტირება გლობალური იყენებთ იმ კონტეინერების.
და რომ აუცილებლად ამცირებს ხარჯები, ისევე როგორც
ზიანის გამო გადაზიდვა.
>> ასე რომ, ჩვენ იგივე მოდელი და ჩვენ ვრცელდება ორ app განვითარების პროგრამა
არქიტექტურა, იმ გაგებით, რომ containerization
აიღო ვირტუალიზაციის ერთ დონეზე.
ასე რომ, ნაცვლად აკეთებს, რომ იმ ტექნიკის დონეზე,
იგი გახდა უფრო ოპერაციული სისტემის დონეზე ვირტუალიზაციის.
>> და ჩვენ გავაკეთებთ, რომ უზრუნველყოფს თითოეული განაცხადის საკუთარი მსუბუქი,
იზოლირებული, runnable და პორტატული, რაც მთავარია,
გზა რეალურად პაკეტი ყველაფერი, რაც მას სჭირდება აწარმოებს.
არსად შეიძლება აწარმოებს.
ასე რომ, მიუხედავად იმისა, თუ თქვენ გაშვებული ეს ადგილობრივი dev გარემოს, თქვენი პროდუქციის
გარემო, თქვენი დადგმა ან ტესტირება.
არ აქვს მნიშვნელობა რა უდევს ინფრასტრუქტურის არის,
თუ არა ფუნქციური სამუშაო app.
>> ასე რომ, სწორედ ის, რაც, ძირითადად, კონტეინერების გავაკეთოთ, რომ ეს პრობლემა.
ისინი მიმართავენ მას შეფუთვის მას ისე,
რომ მას შეუძლია უზრუნველყოს, რომ ის განლაგებული წარმატებით არ აქვს მნიშვნელობა, სადაც ის ცხოვრობს.
ასე რომ, თუ თქვენ აპირებს როგორიცაა, ბობ ის ჯერ კიდევ OK.
თუ თქვენ დაბნეული რა მე ვამბობ, მე ვაპირებ შემუშავების შესახებ, რომ.
>> ასე როგორ Docker თავად ჯდება ამ სურათში?
ასე რომ, Docker ღია პლატფორმა მარტივად, ხაზს ვუსვამთ, ადვილად,
აშენება გემი, აწარმოებს, მსუბუქი პორტატული თვითმმართველობის
საკმარისი app კონტეინერების ყველგან.
ასე რომ, თუ თქვენ მიიღოს რაღაც ამ განხილვა, გთხოვთ შემდეგ.
>> თუ თქვენ გაქვთ თქვენი app გაშვებული ადგილობრივ და განვითარებული ეს
გამოყენებით Docker პლატფორმა, ველით ის წარმატებით განლაგებული.
არ აქვს მნიშვნელობა, რა არის ძირითადი ინფრასტრუქტურა.
ასე რომ, თუ თქვენ გაქვთ Docker კონტეინერი და ეს მუშაობს, მაშინ
რადგან არ არის Docker ძრავის მეორეს side--
თუ თქვენი ოპერაციის ინფრასტრუქტურის გამოყენებით ნებისმიერი Cloud, თუ არა ეს
არის AWS, ან Google- ის, ან Microsoft, ან საჯარო ღრუბლები,
ან საკუთარი Cloud, ან ღია დასტის Cloud, ან თქვენს გარემოში.
>> თუ თქვენ გაქვთ სისტემა გაშვებული, რომ საშუალება
ეს იქნება წარმატებით დისლოცირებული.
ეს იქნება გაშვებული ზუსტად იგივე ქცევა
როგორც თქვენ არქიტექტორი, რომ იყოს.
ასე რომ, თუ ჩვენ გადავხედავთ მე ვაპირებ გაიაროს, რაც, ფაქტობრივად,
არიან ძირითადი კომპონენტების Docker.
>> ასე რომ, ძრავის ძირითადი Docker.
ეს არის ტვინის.
ეს orchestrates შენობა, გადაზიდვა, და შემოყვანა და მართვის
კონტეინერების თავს.
მე იჭრება რა ძრავის აკეთებს უფრო დეტალურად მეორე.
ძირითადად, დოქტორი აშენდა გარშემო კლიენტს სერვერი არქიტექტორები,
იმ მიზნით, რომ ურთიერთქმედება ძრავის თქვენ უნდა გარკვეული კლიენტს.
>> გამოსახულებები თარგები რომელიც კონტეინერების შენდება.
ასე რომ, სურათებით, ძირითადად, მხოლოდ სტატიკური ფაილი.
შაბლონები და კონტეინერები რეალურად რა არის
გაშვებული at runtime, რომ ემსახურება თქვენი განცხადება
ან აკეთებს რაღაც მონაცემებს.
>> რეესტრის მიმართა, როგორც პრობლემა რამდენად რეალურად გავრცელება სურათები.
ასე რომ, თუ თქვენ უნდა გაუზიაროს იმიჯი რომ თქვენ მუშაობდა, რომ თქვენი კოლეგა
ან ops გუნდი, თქვენ გამოიყენოთ ის გამოყენებით რეესტრში.
თქვენ შეგიძლიათ გადმოწეროთ ღია ვერსია, რომელიც Docker მუშაობდა
და გახსნა sourced.
>> ან შეგიძლიათ გამოიყენოთ Docker დახმარება, რომელიც არის Cloud ვერსია
დააყენებს და გაიყვანოს images არსებობს.
ეს არის დიდი რამ.
იმის გამო, რომ დიდი ეკოსისტემის გარშემო Docker და ეს
ნამდვილად მძიმედ გამოყენებით კერა.
>> ასე რომ, შეჯამება აქ, ეს არის, თუ როგორ მინიმალისტური Docker workflow კლიენტს.
თქვენ ურთიერთქმედება მასპინძელი, ამ შემთხვევაში ეს Docker daemons.
ეს არის იგივე როგორც ძრავის.
თქვენ ამის ბრძანებები, როგორიცაა Docker აშენება, გაიყვანოს, აწარმოებს.
და ძრავის თავად მიდის და აკეთებს იმ რამ.
>> ასე რომ, არც ურთიერთქმედებს რეესტრის გაიყვანოს იმ images
და ფენების images.
მიუხედავად იმისა, რომ, თუ გსურთ განათავსოს, აწარმოებს კონტეინერების, კლავს მათ, იმისათვის, რომ მათ ქვემოთ,
whatnot.
ასე რომ, ეს უყრის workflow ყველა ამ კომპონენტს.
>> ასე რომ, თუ თქვენ მიიღოს ყველა კომპონენტი თავისთავად.
ასე რომ, ძრავის, უბრალოდ დემონი.
იგი ყველაფერს სახის ითამაშოს, რომ მხარს ვუჭერთ ეს Linux რადგან ეს იმას
მოითხოვს გარკვეულ Linux kernel თვისებები.
მაგრამ Windows მუშაობს აკეთებს იგივე.
ეს უნდა იყოს მხარდაჭერილი მიერ Windows Server 2016.
>> ასე რომ, კიდევ ერთხელ, პასუხისმგებლობაც ძრავა არის, ან უნდა, ავაშენოთ images.
გაიგეთ სურათები Docker ცენტრი ან საკუთარი რეესტრში.
თუ თქვენ კეთდება იმ სურათები ან შექმნათ ახალი სურათები,
თქვენ შეგიძლიათ დააყენებს იმ უკან რეესტრის გავრცელება მათ სხვა გუნდები.
>> და ცდილობს შეიცავდეს ადგილობრივად და მართვა კონტეინერების ცხოვრების ციკლი
ადგილობრივად.
იგი აგებულია გარშემო HTTP დასვენება API.
ასე რომ ტექნიკურად შეგიძლიათ წერენ საკუთარი კლიენტის
რადგან იგი იყენებს HTTP, რომელიც არის ძალიან სტანდარტული მექანიზმი გაიგო, რომ ძრავის
და ბევრი სხვა.
და თქვენ შეგიძლიათ ნახოთ აქ, მიუხედავად იმისა,
რა ინფრასტრუქტურა არის, რადგან თქვენ can-- ყველა
თქვენ უნდა არის ოპერაციული სისტემა, Linux კონკრეტულად.
>> და შეგიძლიათ დააყენოთ Docker ძრავის თავზე რომ და არ გაშვებული
და ეს orchestrates, ძირითადად, ყველა ამ app ერთი, ორი,
და სამი ფაქტობრივი კონტეინერი.
ასე რომ, ძრავის.
როგორც უკვე აღვნიშნე, რადგან თქვენ უნდა ურთიერთქმედება ძრავის,
იქ კლიენტს.
>> მაგრამ რეალურად, როდესაც თქვენ დააყენოთ Docker, ეს ხომალდები იგი.
ასე რომ, ეს იღებს დაყენებული, ასე რომ, ეს ერთი ორობითი.
და თქვენ შეგიძლიათ ამის ადგილობრივი ზარები თქვენი Docker ძრავის.
ან დისტანციური ზარები დისტანციური ძრავები.
ეს არ გამოიყენოს HTTP, როგორც ვთქვი ადრე.
არსებობს GUI კლიენტის მოუწოდა Kitematic ეხლა Docker.
და არსებობს ნამდვილად ბევრი სხვა ეგ
რომლებიც მშენებლობის ბევრი GUIs, რომელიც ძირითადად განახორციელოს
რამდენიმე HTTP მოუწოდებს გაიგო, რომ ძრავის.
>> უბრალოდ ზოგიერთი ნიმუში ბრძანებები.
თუ თქვენ Docker ვერსია, რომ ის გაჩვენებთ კლიენტის ვერსია, ისევე როგორც
სერვერზე ვერსია.
თუ თქვენ Docker ინფორმაცია, რომ იგი გითხრათ ყველა ინფორმაცია
დაახლოებით რამდენი კონტეინერი გაშვებული ან ის, თუ რამდენი სურათები გაქვთ,
და ასე შემდეგ და ასე შემდეგ.
>> აქ მაქვს, რომ შემდეგი ბოლო ყუთი, მაქვს დოქტორი პერსპექტივაში.
ასე რომ, როგორ მე რეალურად შექმნა კონტეინერი.
და მე რაც ეხმიანება Hello World და ძილის მეორე და whatnot.
და თქვენ შეგიძლიათ ნახოთ შედეგი. ასე რომ, ეს გრძელდება.
და მსგავსი Linux ps, ხედავთ ყველა პროცესების და, ამ შემთხვევაში,
ყველა გაშვებული კონტეინერი.
ეს ერთი მხედველობაში თავში კონტეინერი უბრალოდ შეიქმნა.
>> ასე რომ, ეს ძალიან მნიშვნელოვანია, რადგან, მოსწონს, ეს შეიძლება იყოს ცოტა გაუგებარია.
ასე რომ გამოსახულებები წაუკითხავი კოლექცია ფაილი, არა?
ისინი, რა არის ჩვენი კონტეინერი ეფუძნება.
მაგრამ ისინი მხოლოდ წაიკითხა მხოლოდ.
ასე რომ, თქვენ დაიწყება off ერთად ბაზა იმიჯი.
ეს ტენდენცია, რომ mimic OS, როგორიცაა, ასე რომ Ubuntu, CentOS, whatnot ბაზის იმიჯი.
და მაშინ შეიქმენით თავზე რომ, გარკვეული ფენა, რომელიც ქმნის
თქვენი ბოლოს იმიჯი, საბოლოო ჯამში აქ.
>> და თითოეული იმ ფენებს უნდა ჰქონდეს მშობელს სურათი
ის, რომ ცნობას, როდესაც ის რეალურად სურს შექმნას.
ისინი უცვლელი, იმ გაგებით, რომ რადგან ისინი წაკითხული მხოლოდ,
თქვენ არ შეგიძლიათ რეალურად ცვლილებების შეტანა მათ.
თქვენ შეგიძლიათ გამოიყენოთ, რათა შეიქმნას კონტეინერი იმიჯი, რომელიც
მოვუწოდებთ ყველა მომდევნო საჭირო images ქვეშ.
>> თქვენ შეგიძლიათ შეიტანოთ ცვლილებები სხვადასხვა ფენის,
ეს არის ხელმეორე ფენის მე ვისაუბროთ მეორე.
მაგრამ თითოეული იმ ფენებს არასოდეს შეცვლილა.
ძირითადად გამოსახულებები გამოიყენოთ რაღაც მოუწოდა კავშირის ფაილი სისტემის, UFS.
არსებობს სხვადასხვა შენახვის backends, რომ გამოიყენოს ეს ტექნოლოგია.
და იმას ნიშნავს, რომ ის, რომ აერთიანებს მკაფიო ფაილური სისტემა
რათა მათ გამოიყურებოდეს ერთი.
>> ასე რომ თქვენ შეგიძლიათ რეალურად, საწყისი განაცხადის პერსპექტივა,
თქვენ გაქვთ საუკეთესო ხედი, რომელიც გვიჩვენებს ყველა სხვადასხვა ფაილური სისტემა საჭირო
ამ განაცხადს აწარმოებს.
მაგრამ ისინი, ფაქტობრივად, ამ, ისინი, ფაქტობრივად, ცალკე ადგილებში
და გამოყენებული სხვა კონტეინერების, ასევე.
>> ასე რომ, როგორც ხედავთ, აქ რომ თუ ჩვენ დავიწყებთ daemon სურათი
როგორც ბაზა იმიჯი და შემდეგ ჩვენ წავიდეთ და დაამატოთ [? emacs?]
და მაშინ, რომ ის კიდევ ერთი ფენა.
და შემდეგ დაამატოთ Apache.
ეს არის კიდევ ერთი ფენა.
და მაშინ ჩვენ გაატაროთ კონტეინერი რომ.
თითოეული მათგანი, სურათებით, თითოეული იმ ფენებს,
მკაფიო და შეიძლება reused სხვა კონტეინერი.
>> თუ გადავხედავთ კონტეინერების თავს, ისინი რატომღაც მსგავსი VM მსგავსი,
მაგრამ არ განიხილება, ამავე დროს.
ასე რომ, მათ არ აქვთ, რომ ტექნიკურად, სრულ ოპერაციული სისტემა ქვეშ მათ.
ისინი იყენებენ ერთ kernel მასპინძელი ოპერაციული სისტემა.
ხოლო მათ ავაშენოთ თავზე რომ.
ისინი mimic თუ როგორ გამოიყურება.
ისინი mimic მათი ფაილური სისტემა ოპერაციული სისტემა.
მაგრამ ისინი, ფაქტობრივად, არ მოშენება.
>> ასე რომ, ნაცვლად, რომელმაც უცვლელი ფენებს, ბოლო ფენა, რომელიც არის კონტეინერი
თავად, ეს წაკითხული ჩაწერის ფენა.
რომელიც ასევე გადის პროცესების თქვენი განაცხადი.
ეს დამოკიდებულია ფუძემდებლური ფენებს.
ყოველ კონტეინერი ის საწყისი იმიჯი.
და რომ გამოსახულება შეიძლება იყოს ერთი ფენის ან მრავალშრიანი იმიჯი.
>> და მე მინდა აღვნიშნო, რომ აქ რომ Docker მძიმედ იყენებს,
ან ეფუძნება Copy-On-Write მექანიზმი.
ასე რომ, რეალურად, თუ თქვენ არ ხართ ცვლილებების კონტეინერი,
ის არ აპირებს მიიღოს დამატებითი ფართი.
ასე რომ, ძირითადად, თუ როგორ შეაჯამოს Copy-On-წერე.
ის აპირებს აუცილებლად დააჩქარებს ჩატვირთვის დრო კონტეინერი.
იმიტომ, რომ თუ თქვენ არ მიღების ცვლილებები კონტეინერი,
ის გამოყენებით, რაც უკვე არსებობს.
>> ასე რომ, თუ ის რეალურად მუშაობს.
ნაწილი ეს იგივეა, ახლა, იყენებს მინიმუმ ორი ძირითადი ბირთვის
მახასიათებლები.
და, რომ ეს არის ის, რაც ის, რომ მათში იზოლაცია
იმ კონტეინერების თავს.
იმ თვისებებია სახელთა და cgroups.
ასე რომ, სახელთა არის გზა შექმნა იზოლირებული რესურსები,
ისე, რომ შიგნით კონტეინერი თავად, მხოლოდ თქვენ შეგიძლიათ ნახოთ გარკვეული რესურსები.
როგორიცაა ქსელის ინტერფეისი ან გარკვეული წევრებს ან whatnot.
>> და ეს არის მხოლოდ ხილული და მხოლოდ ხელმისაწვდომი ფარგლებში კონტეინერი.
Cgroup მეორე მხარეს ლიმიტები თუ როგორ გამოიყენოთ ის რესურსები.
CPU, მეხსიერება და დისკზე.
როდესაც თქვენ შეიძლება წავიდეს, მე ნიშნავს ეს არის, ფაქტობრივად
თვისებები, რომლებიც განვითარებული by-- ისინი ნაწილი Linux kernel.
ასე რომ, ისინი არ ხელახლა მიერ და აღდგენილია Docker.
Docker იყენებს მათ.
>> რა ექიმი მართლაც აქ არის რეალურად ეს
Orchestrated შექმნა სახელთა თითოეული კონტეინერი
და ქმნის cgroups ისე, რომ ეს ridiculously ადვილად შექმნათ კონტეინერი
გამოყენებით იმ თვისებები.
რა თქმა უნდა, როგორც მე აღწერილი ადრე, კავშირი ფაილის სისტემები და Copy-On დაწერეთ ნამდვილად
დაეხმაროს სიჩქარე და დისკზე გამოყენების კონტეინერი.
>> და კიდევ თქვენ თქვენი ხელში გარშემო Docker,
თქვენ აპირებს, თუ რამდენად სწრაფად არის ის, რომ რეალურად დაიძაბება up კონტეინერები და ცრემლსადენი
მათ ქვემოთ.
ასე რომ, თუ თქვენ შეიძლება იკითხოთ, თუ როგორ შეიძლება თქვენ რეალურად აშენება სურათები?
ჩვენ ვაშენებთ სურათები მიერ შექმნის პროცესი კონტეინერები და ცვლილებების შეცვლის
მათ, და გადასცემდა შევიდა ხდება იმიჯი.
>> ასე რომ, ეს ქათამი და კვერცხი მინიშნება აქ,
იმიტომ, რომ ყველა კონტეინერი მოდის სურათები და გამოსახულებები მოვა
საწყისი ჩადენილი კონტეინერების, უმეტეს წილად.
არსებობს სამი ვარიანტი შექმნათ გამოსახულება.
მე ვაპირებ აღწერს პირველი და ბოლო.
თქვენ შეგიძლიათ ხელით წასვლა და აწარმოებს კონტეინერი
და ეს ცვლილებები, როგორც გსურთ ამის გაკეთება ნებისმიერ VM
ან ნებისმიერი ოპერაციული სისტემის, როგორიცაა დაყენების ახალი binaries,
დასძინა, ფაილური სისტემა, და whatnot.
>> და მაშინ გასვლა, რადგან თქვენ შეგიძლიათ ნახოთ აქ.
მე არსებული ჩემი კონტეინერი.
და მაშინ მე ვაკეთებ Docker ჩაუდენია.
და მე ჩადენის რომ.
თქვენ ხედავთ, რომ ნომერი აქ მხოლოდ UUID, ან პირველ 12
ბიტი UUID.
ან ბაიტებში UUID.
და მაშინ მე ამას ჩემი იმიჯი.
ასე რომ, ახლა Docker ზრუნავს ჩაწერა ყველაფერი, მე ეს
და შექმნა ახალი სურათი დაყრდნობით.
>> მე არ ვაპირებ ვისაუბრო tarball, მაგრამ არსებობს გზით თქვენ შეგიძლიათ მიიღოთ ერთი,
შექმნა ერთი, ან ერთი ფენის გამოსახულების გამოყენებით tarballs.
რა მე ვაპირებ, რომ ვისაუბროთ ამ და რა ძირითადად გამოიყენება დღეს,
არის Dockerfile.
რაც ტექნიკურად პირველი ნაბიჯ ავტომატიზირებულია Docker თავად.
ასე რომ, Dockerfiles რამ, რომ თქვენ ვაპირებთ, რომ ნახოთ ბევრი GitHub repos
დღეს.
ეს, ძირითადად, მხოლოდ ტექსტური ფაილი, რომელიც აღწერს
ზუსტად თუ როგორ უნდა ავაშენოთ იმიჯი.
>> და ყველა ხაზი, სინამდვილეში ეს ქმნის კონტეინერი, ახორციელებს, რომ ხაზი,
ვალდებულებას, რომ კონტეინერი შევიდა ახალი იმიჯი, და თქვენ, ძირითადად,
გამოვიყენოთ ყველა მომდევნო ოპერაციების სანამ ბოლო იმიჯი.
რომელიც ძირითადად დასრულდება მიზანი აქ, ბოლომდე.
ხოლო მას შემდეგ, exec-- მას შემდეგ, რაც დაწერეთ თქვენი Dockerfile, რომელიც
წმინდა ტექსტი, თქვენ აკეთებთ Docker აშენება და სახელი იმიჯი.
>> და თქვენ აღვნიშნო, რომ ეს არის სადაც Dockerfile არის.
და თქვენ შეგიძლიათ ველით, რომ ნახოთ ჩემი სურათი როგორც სურათი, რომ თქვენ გაქვთ ადგილობრივად.
ასე რომ, მხოლოდ ვიზუალური მაგალითად, თუ რა მიდის.
თქვენ იწყება ბაზის იმიჯი.
თქვენ აწარმოებს, რომ კონტეინერში, რომელიც არ შეცვალოს ბაზის იმიჯი თავად.
მაგრამ იმის მაგივრად, ქმნის გადაწერა ფენის თავზე,
სადაც თქვენ მიიღოს ცვლილებები, თქვენ ჩაიდინოს
და ვიმეორებ, ამ პროცესში თქვენ თქვენი საბოლოო გამოსახულება.
>> და ამით, ყოველ მეორე build პროცესში შეგიძლიათ გამოიყენოთ იგივე ფენების
და same-- ძირითადად Docker caches იმ ფენებს.
ასე რომ, თუ მე ვაკეთებ ზუსტად იგივე პროცესი, მაგრამ ნაცვლად დაყენების PHP,
მე დაყენების Python.
ის აპირებს გამოიყენოს Apache და Ubuntu.
ასე რომ გზა თქვენ გამოყენებით თქვენს დისკზე.
ის გამოყენებით ქეში და ხელმისაწვდომი სურათები არსებობს.
>> საბოლოო ცალი რეესტრი, რომელიც არის, თუ როგორ გავრცელება თქვენი images.
და, როგორც ზემოთ აღინიშნა, არ არის Cloud ვერსია ეს,
რომელიც Docker ცენტრი.
თქვენ შეგიძლიათ წასვლა და შეისწავლონ ბევრი, ძირითადად
ეს არის საჯარო SAS პროდუქტი, რომელიც თქვენ შეგიძლიათ კიდევ აქვს პირადი სურათები,
მაგრამ არსებობს ბევრი საჯარო images.
ეს, ფაქტობრივად, შეუზღუდავი, შეგიძლიათ დააყენებს შეუზღუდავი საჯარო სურათები არსებობს.
და ეს არის, თუ როგორ შეგიძლიათ თანამშრომლობა თქვენი გუნდი.
>> შეგიძლიათ უბრალოდ აღვნიშნო მათ თქვენ Repo და ისინი შეგიძლიათ გადმოწეროთ ან თქვენი სურათი
და ისინი შეგიძლიათ გადმოწეროთ.
ასე რომ, საკმარისი განხილვა.
ვისაც სურს, რომ ზოგიერთი demos რეალური სწრაფი?
კარგი.
ასე რომ, აქ მაქვს.
Ca თქვენ ბიჭები ვხედავ ჩემს ეკრანზე?
კარგი.
>> ასე რომ, მე Docker გაშვებული აქ, ასე რომ მე შეგიძლიათ ნახოთ it's-- ეს არის მობილური
საქართველოს Docker, რომელიც გაშვებული.
შეგიძლიათ გააკეთოთ Docker ინფორმაცია.
შეამოწმეთ ყველა ინფორმაცია, თუ რამდენი სურათები აქვთ, და ასე შემდეგ და ასე შემდეგ.
Docker PS, არაფერი გაშვებული.
Concatenated იმ.
>> ასე რომ, პირველი, რაც მე მინდა, რომ შოუ თუ როგორ შეგიძლიათ ადვილად აწარმოებს კონტეინერი.
ასე რომ, სილამაზის შესახებ დოქტორი პერსპექტივაში, თუ ის რეალურად
არ იპოვოს გამოსახულება ადგილობრივად, იყოს იგი საუბრობს დოქტორი ცენტრი
ის ცდილობს იპოვოს ის არსებობს და ის თქვენთვის.
ასე რომ, ეს მოიცავს Docker დახევის ბრძანება, ბუნებრივია.
>> ასე რომ, თუ გავაკეთო Docker პერსპექტივაში, hello მსოფლიოში.
ასე რომ, პირველი, ის აპირებს ცდილობენ, რათა იპოვოს იგი.
წინააღმდეგ შემთხვევაში, როგორც ხედავთ აქ, ის ვერ მიაგნეს ადგილობრივად.
ახლა ეს უბრალოდ გამოყვანილია ორი ფენა რომ გააკეთა, რომ გამოსახულება და მე გაიქცა.
გამარჯობა სამყაროში მხოლოდ ძირითადად შედეგები, რაც თქვენ გააკეთეთ.
ასე რომ, ეს არის მარტივი, ერთი მარტივი მაგალითები.
ასე რომ, რეალურად მე უბრალოდ გაიქცა და შეწყვეტილი კონტეინერი რეალური სწრაფი.
>> თუ მინდა, რომ პერსპექტივაში და, სხვათა შორის, თუ მე მინდა, რომ დრო, რომ, უბრალოდ, ასე რომ თქვენ იცით,
ეს არის რამდენი ხანი სჭირდება რეალურად დაიძაბება და შეიცავდეს იგი.
ჩვენ საზომი ის მილიწამებში.
ასე რომ თქვენ ხედავთ, რამდენად შეუძლია რეალურად დაგეხმარებათ არა მხოლოდ ტესტირება,
არამედ კიდევ განლაგებას.
ასე რომ, სწრაფი შენიშვნა, რომ.
შემდეგი რამ, მე ვაპირებ ამის გაკეთებას ფაქტიურად
აწარმოებს იმიჯი მე უკვე მომზადებული.
ასე რომ, არსენ პერსპექტივაში.
დ არის მხოლოდ დროშა ვუთხრა იგი აწარმოებს ფონზე.
და -p ანიჭებს გარკვეული პორტები.
იმის გამო, რომ, ჩვეულებრივ, კონტეინერების იზოლირებული,
ასე რომ თქვენ უნდა მიუთითოთ ზუსტად , როგორ შეუძლიათ მათ.
და ამ შემთხვევაში, მე ვეუბნებოდი Docker რუკაზე შემთხვევითი პორტი მასპინძელი
მითითებულ პორტში ფარგლებში კონტეინერი თავად.
და ეს, ძირითადად, სადაც image-- იმედია, რომ ეს უფლება ერთი.
>> ასე რომ, ეს იმას პარალელური გადმოტვირთვა თითოეულ იმ ფენებს, როგორც ხედავთ აქ.
ეს არის ფენების მიღების ბოლოს იმიჯი რომ მე აგებული.
იგი აპირებს მიიღოს მეორე.
და voila.
>> ახლა, თუ ამის გაკეთება docker ps, მე უნდა ვხედავ, რომ რაღაც არის გაშვებული.
მე უნდა ნახოთ ID, იმიჯი რომ ეს იყო დაფუძნებული off,
და ბრძანება, რომელიც სიკვდილით დასაჯეს.
და როგორ უნდა თქვათ, რომ ეს არის ძირითადად წასვლა რომ პორტი.
ამიტომ, მე ვაპირებ წასვლა, რომელთა მიზანია ამ არის მე გაშვებული AWS.
მე ვაპირებ წასვლა 32769.
Oops.
და აქ ჩვენ მივდივართ.
>> ასე რომ, ეს არის რეალურად მხოლოდ ვებ მომსახურება, რომელიც აჩვენებს
რომელიც კონტეინერი ის მიმდინარეობს მსახურობდა.
ასე რომ თქვენ ხედავთ, რომ ეს არის კონტეინერი a9f.
აქ ეს არის ასახელებს კონტეინერი.
ასე, რომ თქვენ ბიჭები ვხედავთ, რამდენად სწრაფად იყო რეალურად არა მხოლოდ გაიყვანოს არამედ
განათავსოს ამ კონტეინერში.
>> ახლა შემდეგი ნაბიჯი არის გავერკვეთ Dockerfiles
და როგორ შეგვიძლია რეალურად ავაშენოთ ახალი images.
მე უბრალოდ აპირებს წავიდეთ მისაღებად კლონი, რომელიც ნიმუში Dockerfile საფუძველზე ადრე
სქემა, ერთი Apache და PHP.
იმედია მახსოვს ჩემი რეპო.
>> ასე რომ, მე მაქვს ჩემი საცავი ახლავე.
და თქვენ ვაპირებთ ვხედავ ეს ბევრი რეალურად.
მე არ დააყენოთ ხე.
>> ასე რომ, ძირითადად, თქვენ აპირებს ვხედავთ, თუ როგორ თქვენი კოდის დოკუმენტაცია გარშემო
იგი, და მაშინ Dockerfile on როგორ რეალურად პაკეტი იგი.
ასე რომ, ეს მხოლოდ ნიმუში PHP რომ ეხმიანება მიესალმები CS50.
>> ასე რომ, თუ გსურთ, რომ აწარმოებს, მე ყველაფერს გავაკეთებ docker კორპ.
მე უნდა ავაშენოთ იგი.
მე ვაპირებ დაარქვით demo_cs50.
და თქვენ უნდა აქვს, რომ ეს ძალიან.
ასე რომ, მოდით, მას V1 dot.
ასე რომ, როგორც მე აღწერილი ადრე, რასაც მე ვაკეთებ დღეს
არის მე ვეუბნებოდი Docker წასვლა გამოყენება that-- ფაქტობრივად, ბოდიში, ჩემი ცუდი.
ჩვენ არ შევხედოთ იმ Dockerfile თავად.
ასე რომ, ერთადერთი რამ აქ index.php ისევე როგორც readme ფაილი
და Dockerfile.
>> ასე რომ, თუ შევხედოთ Dockerfile, ამიტომ
ძალიან გავს რა მე აღწერილი ადრე.
ეს არის მხოლოდ bunch of ნაბიჯი, რომელიც Docker ახორციელებს
შექმნით და ჩამოხევა კონტეინერები და [? დათვლა?] მათ იმიჯი.
>> და ძირითადად შეგიძლიათ see-- [INAUDIBLE] ეს აქ
მაგრამ ეს არ არის ადგილობრივი რეპო.
ის აპირებს წავიდეს და დაიბრუნოს index.php.
ასე რომ, მხოლოდ კოდის რომ არიან რეალურად ნაწილი თქვენი განაცხადი.
ეს ყველაფერი ძირითადად ოპერაციული სისტემა სანტექნიკა,
მიღების უფლება პაკეტები და Apache და PHP, და whatnot.
მაგრამ ეს არის რეალურად აღება index.php და ჩადენაში კონტეინერი,
იმიჯი.
>> ასე რომ, თუ თქვენ წავიდეთ წინ და აწარმოებს ბრძანება აკეთებს შემდეგ,
ის going-- ფაქტობრივად, ეს შეიძლება ცოტა.
იმედია ეს არ იღებს ძალიან დიდი ხნის განმავლობაში.
ასე რომ თქვენ ხედავთ ნაბიჯები.
და მე მოგიწოდებთ თქვენ წავიდეთ სახლში დღეს და ცდილობენ.
და Mano აღწერს როგორ ზუსტად თქვენ, რომ.
მაგრამ ეს მართლაც დიდი, ზუსტად რა ხდება კულისებში.
მაგრამ ეს სასაცილოდ ადვილია აშენება სურათები და განათავსებს მათ გამოყენებით Docker.
>> ეს აღების ცოტა უმეტეს ველოდი.
>> ვნახოთ, რა მოხდება, როდესაც you-- გაგრილებას.
ასე რომ, როგორც ხედავთ, თითოეული იმ ნაბიჯებს, წარმოადგენს ხაზები Dockerfile.
და ეს გვიჩვენებს, რომ ეს წარმატებით აშენდა ეს იმიჯი.
>> ასე რომ, თუ docker სურათები, მე ვაპირებ ყველა სურათები რომ მაქვს ადგილობრივად.
და ერთ-ერთი მათგანი ეწოდება ჩემი სახელი და სახელი იმიჯი,
და tag representing-- ძირითადად, ეს არის პორტალის მობილური აქვს.
>> ასე რომ, ახლა თუ მინდა აწარმოებს ის, მე docker პერსპექტივაში.
და მე მინდა, რომ გავაკეთოთ დ -P. ნუ v1.
ასე რომ, მე ვხედავ, რომ მე მაქვს ორი კონტეინერების გაშვებული, ერთი, რომ მე მხოლოდ
შეიქმნა და მიესალმები Docker ერთი, რომ მე მივიღე ბოლო.
>> და თქვენ შეგიძლიათ ნახოთ აქ, რომ ეს ენიჭება სხვადასხვა პორტი.
ასე რომ, თუ მე წასვლა იგივე IP მაგრამ მივანიჭოთ მას სხვადასხვა port-- იმედია მე არ.
ასე რომ, ახლა ეს განცხადება რომ მე უბრალოდ განლაგებული.
>> თუ მინდა, რომ ცვლილებები, მე სწრაფად რედაქტირება კოდი
და ამის შემდეგ.
მოდით გამარჯობა ჰარვარდის.
ასე რომ, ახლა რა ხდება უნდა მოხდეს, რომ მე
აპირებს, რომ მონიშნო იგი სხვადასხვა version-- oh,
არ არის ეს guy-- მონიშნო იგი სხვადასხვა ვერსია.
და თქვენ აპირებს see-- თქვენ ბიჭები ველით
მას მიიღოს იმავე დროის აშენება მას მეორედ თუ არა?
ყველა უფლება, და არავინ იცის, რატომ?
Speak up.
>> აუდიტორია: [INAUDIBLE]
>> NICOLA KABAR: ეს, ძირითადად, ჩვენ მხოლოდ შეცვალოს ერთი შემდეგ ნაბიჯები.
და, შესაბამისად, ის აპირებს გამოიყენოს ქეში და გამოიყენოთ თითოეული იმ ფენებს.
და ეს მართლაც ზოგიერთი მკვლელი თვისებები Docker
არის, თუ როგორ რეალურად იყენებს და reuses აღების გამო
თქვენს დისკზე იგივე ზუსტი ცალი ინფორმაციას.
>> ასე რომ, თუ ჩვენ გავაკეთოთ იგივე, დასჭირდა მხოლოდ რამდენიმე წამში.
თუ გვინდა, რომ redeploy-- ასე რომ, ახლა მე უნდა სამი კონტეინერი.
მაგრამ ეს ერთი მიმდინარეობს მსახურობდა the-- შვიდი ერთი.
ასე რომ, ახლა ეს არის მესამე კონტეინერი.
ყველას გვესმის, რაც მე უბრალოდ გააკეთეს აქ?
>> ასე რომ, ახლა, თუ გსურთ გაუზიაროს ეს კონტეინერი რეალური სწრაფი თქვენს მეგობრებს
თქვენ შეგიძლიათ ამის docker დააყენებს ასახელებს კონტეინერი, იმედია.
ასე რომ, ახლა ის აპირებს დააყენებს რომელთა მიზანია მე არ შემოვიდა აქ.
ვწუხვარ ამის გამო.
მაგრამ მე არ ვაპირებ პრობლემების ახლა.
მაგრამ, ძირითადად, რომ ერთი ბრძანება არის მხოლოდ იზრდებოდა დააყენებს მას.
და თქვენ აპირებს შეძლებს ვხედავ, რომ თუ წასვლა Docker ცენტრი
თქვენ შეხვიდეთ თქვენ იქნება ნახოს ის.
და მაშინ თქვენ შეგიძლიათ უბრალოდ მეტიც, ვინც აპირებს
უნდა გამოვიყენოთ, რომ იმიჯი უნდა წავიდეს და გაიყვანოს მას.
და მათ შეუძლიათ გამოიყენონ იგი.
>> ამასთან ერთად, იმედია I ტიპის აჩვენა
რა ადვილი არის, მუშაობა Docker.
და მე უბრალოდ აპირებს მისცემს მას უკან Mano.
და ის აპირებს მას აქედან.
>> MANO MARKS ყველა უფლება მადლობა, მადლობა ნიკო.
მერე რა?
ასე რომ, ერთი რამ, რაც მე მინდოდა ამის გაკეთება დააყენა ერთად
რატომ ეს არის important-- რატომ Docker და რატომ
კონტეინერების ასეთი მნიშვნელოვანი ახალი განვითარება,
ახალი გზა რეალურად აკეთებს პროგრამული უზრუნველყოფა.
>> და სანამ მე, მე ვაპირებ უბრალოდ წარმოგიდგინოთ რამდენიმე სტატისტიკა.
მე არ ვაპირებ, რომ წავიკითხე ეს ყველაფერი.
მაგრამ ეს გვიჩვენებს, თუ ბევრი, თუ როგორ პოპულარული ეს არის საზოგადოების.
ძირითადი Docker ტექნოლოგიები არის ღია.
ასე რომ, Docker ძრავის, შედგენა, Swarm, რამოდენიმე სხვა პერსონალი
ყველა ღია წყაროებიდან.
და ჩვენ, რა მე ამბობენ, 1300 ავტორები.
თქვენ ახლა ვხედავთ, თუ გადავხედავთ რაოდენობის ვაკანსიები, ბოლო დროს
ჩვენ ჩანდა, რომ ეს იყო დაახლოებით 43,000 სამუშაო ვაკანსიებს მოიხსენია
იმ Docker.
ასობით მილიონი გამოსახულებები უკვე გადმოწერილი Docker ცენტრი.
და, ასევე, ბევრად უფრო დიდი stats.
>> მათთვის, ვინც აინტერესებს, ის თავდაპირველად დაწერილი Python
და შემდეგ გადაწერილი შევიდა Go.
და ეს მხოლოდ გახსნა წყაროს, ეს მხოლოდ
გაათავისუფლეს დაახლოებით 2 1/2 წლის განმავლობაში, რაც იმას ნიშნავს, რომ 2 და 1/2 წელი,
ჩვენ ვნახეთ უზარმაზარი თანხა ზრდის და მნიშვნელობა
ამ თანამეგობრობაში.
ასე რომ, მინდა გაიგო ცოტა შესახებ, თუ რატომ.
>> ასე რომ, უბრალოდ კიდევ ერთხელ გავიმეორო, ზოგიერთი Nico ის ძირითადი პუნქტები, Docker არის სწრაფი.
ეს არის პორტატული.
ეს არის ზუსტი.
და ეს ქმნის სტანდარტული გარემო.
>> და what-- ეს არის ჩემი crappy ბეჭედი მონოლითი slide-- რა
ეს ეხმარება ხალხი, რომელიც ბევრი პროგრამული უზრუნველყოფის ინდუსტრიაში
დაიწყო აკეთებს 2000-იან წლებში, მოძრაობს
ამ მონოლითური ერთ განაცხადების
სადაც ყოველი დამოკიდებულება უნდა იყოს ტესტირება, სანამ მთელი app ჰქონდა
იყოს განლაგებული, რომელიც შეიძლება ნიშნავს ნახვა
მხოლოდ განლაგდნენ ერთხელ ყოველ სამ თვეში, ან მეტი,
ბევრად უფრო მომსახურება ორიენტირებული არქიტექტურის
ან componentized სხვადასხვა ტიპის განაცხადის არქიტექტურა.
ასე რომ, რომელიც საშუალებას ამ სახის არქიტექტორები
რომ ისარგებლოს Docker აწარმოებს ამ სამ
ძირითადი პრიორიტეტული სფეროს განვითარებას, რომელიც არის განვითარების წერილობით თქვენი ფაქტობრივი კოდი,
ტესტირება თქვენი კოდი და შეჰყავთ მას.
>> რატომ არის ეს მნიშვნელოვანი?
თუ თქვენ a-- მიადევნე თვალი მისცეს მაგალითი.
თუ თქვენ ხართ ნახვა მოწყობილობა დეველოპერი, თქვენ
განვითარებადი საიტი, რომელიც ეფუძნება მონაცემთა ბაზა, რომელიც დავით წარმოებული მეტი აქ.
უკაცრავად, დავით, მე მოვუწოდებ თქვენ გარეთ.
თუ უნდოდა განათავსოს მთელი რამ, ნეტავ
უნდა ველოდოთ ქვეშ ტრადიციული მონოლითური პროგრამული უზრუნველყოფის დამუშავება
გარემოს, ნეტავ უნდა ველოდოთ სანამ იგი კეთდება მონაცემთა ბაზაში
სანამ შეიძლება რეალურად მიიღოს ნებისმიერი ცვლილებები თქვენს საიტზე.
ნეტავ უნდა გადაიყვანოს მთელი განაცხადის ამის გაკეთება.
>> და რა Docker ეხმარება თქვენ ყოველ პირი მუშაობა სხვადასხვა კომპონენტები
განახლება და მათ, როგორც ისინი, უბრალოდ მიღების დარწმუნებული ვარ, რომ ინტერფეისი იგივე რჩება.
ასე რომ, ის, რაც გააკეთა არის ის გადაინაცვლებს ადამიანი
საწყისი აკეთებს ამ მასიური მონოლითური არქიტექტორი პროგრამული უზრუნველყოფა, რომელიც
განლაგებული ყოველთვიურად უწყვეტი ინტეგრაციისა და უწყვეტი განვითარების
გარემო.
>> ახლა ეს არის უნიკალური Docker, მაგრამ Docker ხდის ასე ბევრად უფრო ადვილია,
რაც იმას ნიშნავს, თქვენ ძირითადად მუდმივად შეჰყავთ.
ჩვენ გაიგო, რომ საწარმოების შემოყვანა საჯარო წინაშე პროგრამები
ათასობით ჯერ დღეში, რადგან ხედავენ ღირებულების მხოლოდ მიღების
მცირე ცვლილებები, და სანამ როგორც იგი გადის გამოცდას,
გაქირავების ეს გასვლა შევიდა წარმოების.
ნიკო ყოველთვის მეუბნებოდა აღინიშნა, რომ ბევრ გარემოში,
სტანდარტული ცხოვრების ციკლი კონტეინერი იზომება წამში,
ხოლო ვირტუალური მანქანა შეიძლება გაიზომოს თვის განმავლობაში.
>> მინდოდა უმნიშვნელო აქციოს აქ იმიტომ, რომ მე
განთავსებულია საგანმანათლებლო დაწესებულება.
მინდოდა მისცეს მაგალითი, თუ როგორ ეს მუშაობს საგანმანათლებლო კვლევები
სიტუაცია.
ასე რომ, არსებობს ორგანიზაცია მოუწოდა bioboxes.
Bioboxes აკეთებს დნმ ანალიზი მკვლევარები.
>> ახლა რა მათ აღმოაჩინეს, რომ როდესაც researcher-- და ეს არ არის
ბრალია, რაიმე განსაკუთრებული researcher-- მაგრამ როდესაც
მკვლევარი განლაგებული ალგორითმი ანალიზი,
კონკრეტული გზა, დნმ ნიმუში, ისინი წერენ პროგრამული უზრუნველყოფა,
გამოაქვეყნოს, რომ, იქნებ GitHub ან სადმე სხვაგან,
და მაშინ ისინი გაკეთდეს.
>> ისე პრობლემა ის იყო, რომ არ იყო აუცილებელი, განმეორებადობა.
იმის გამო, რათა გასაგებია პროგრამული უზრუნველყოფა,
ისინი უნდა შეიქმნება ზუსტი განვითარების გარემო
, რომ მკვლევარი გამოიყენება, როგორც წესი, მათი ლეპტოპი, ან სერვერზე, ან მონაცემთა
ცენტრი, რომ ისინი გამოყენებით.
და, შესაბამისად, ეს იყო ძალიან რთული რეპროდუცირება კვლევის შედეგები, როდესაც
ანალიზის დნმ-ის ნიმუშები უნდა ვეძებოთ რამ, როგორიცაა incidence--
შედარების შემთხვევაში გულის შეტევები საფუძველზე გარკვეული გენების ყოფნის,
მაგალითად, ან კიბოს რისკი, ან ნებისმიერი სხვა სახის ნივთები.
>> ასე რომ, რა გააკეთეს მათ ნაცვლად იყო ისინი დაიწყო კონტეინერი.
და თქვენ შეგიძლიათ წასვლა bioboxes.org, ეს არის დიდი ორგანიზაცია.
და რას აკეთებს არის ისინი აწარმოებენ კონტეინერების კვლევის საფუძველზე.
და მაშინ, როდესაც ვინმეს აგზავნის მათი ნიმუში, მათ შეუძლიათ აწარმოებს.
და მას აქვს ყველა გარემო საჭიროა გასაშვებად, რომ ალგორითმი
და აწარმოოს შედეგები.
და ისინი მოძიებაში, რომ ისინი ბევრად უფრო და უფრო
უფრო სწრაფად შეუძლია დაბრუნდება შედეგების ხალხს.
>> და სინამდვილეში, რას აკეთებს გაშვებული საკუთარი ანალიზი დნმ,
გაგზავნის, რომ უნდა bioboxes და მაშინ biobox უბრალოდ იღებს მონაცემებს,
გადის ის წინააღმდეგ სხვადასხვა სხვადასხვა კონტეინერების
იმისათვის, რომ ნახოთ სხვადასხვა შედეგებს ეფუძნება სხვადასხვა კვლევა.
ასე რომ, ეს ძალიან ძლიერი გზა, რომელიც მკვლევართა
შეუძლია ერთი შემთხვევა, რომელიც საშუალებას აძლევს სხვა ხალხს ცდილობენ და აღვადგინოთ
შედეგები.
>> ასე რომ, როგორ დავიწყოთ?
ჩვენ კარგად მხარდაჭერა Linux.
ასე რომ, თუ გსურთ დააყენოთ არაფერი Linux,
თქვენ იყენებთ თქვენი სტანდარტული პაკეტი მენეჯერი ინსტალაცია.
თუ თქვენ იყენებთ Debian, ეს apt მისაღებად.
CentOS არის yum.
Fedora Red Hat არის rpm-- მე არ მახსოვს.
ყოველ შემთხვევაში, ეს ყველაფერი არსებობს.
ჩვენ მხარს ვუჭერთ ფართო საქართველოს ლინუქსის დისტრიბუტივების.
თქვენ შეგიძლიათ შეამოწმოთ იმ გარეთ.
>> ჩვენ ასევე გვაქვს ვარიანტი, ასე რომ თქვენ შეიძლება აწარმოებს on Mac და Windows.
ახლა ნიკო ზემოთ აღინიშნა, რომ ეს იყო მხოლოდ მხარდაჭერა Linux.
ეს სიმართლეა, რადგან ეს სჭირდება Linux kernel.
მაგრამ, თქვენ შეგიძლიათ აწარმოებს ვირტუალური მანქანა.
და რა Docker ძიება აკეთებს, რომელიც შეგიძლიათ ჩამოტვირთოთ,
ეს გაძლევთ, რომ ვირტუალური მანქანა.
>> ასე რომ, უბრალოდ სწრაფი 48 მეორე, მე ვფიქრობ, რომ ჩამოტვირთოთ.
თქვენ უბრალოდ ძიება Docker ინსტრუმენტები, გადმოწეროთ Mac,
და ეს ნაწილი არის რა თქმა უნდა დაჩქარდეს, რადგან, ვინც
უნდა უყუროთ ჩამოტვირთვა სიგნალი?
სტანდარტული Mac მონტაჟი, და მაშინ თქვენ
ვაპირებთ, რომ ნახოთ Jerome დააყენა თავის დაგავიწყდათ.
ეს არის ძალიან საინტერესო.
და მაშინ ის მოყვება მთელი bunch of ინსტრუმენტები.
და განსაკუთრებით ეს იქნება დააყენოთ ბრძანების.
და მაშინ ვერ ვხედავ Jerome ტესტირების მისი images.
>> და შემდეგ ამ საფუძველზე, თქვენ ხედავთ, რომ YouTube
ფიქრობს, რომ ნიკო არის დაინტერესებული Star Wars, The Jimmy Kimmel შოუ,
და მე ვფიქრობ, ელენე.
მე ვფიქრობ, რომ ბოლო ერთი კლიპი საწყისი Ellen შოუ.
>> ასე რომ, Docker ძიება იმისა, რომ მოდის მეტი, ვიდრე უბრალოდ Docker მანქანა.
ასე რომ, Docker მანქანა ის, რომ ეხმარება
შეიქმნა ვირტუალური მანქანა თქვენს Windows
ან Mac-- თქვენი Windows ყუთი ან თქვენი Mac ყუთში და ეხმარება თქვენ უზრუნველყოფასთან,
>> მაგრამ მას ასევე გააჩნია Swarm და შედგენა,
რომლებიც განკუთვნილია რათა დაგეხმაროთ თქვენ დიდი მასშტაბის დისლოცირებას თქვენი განაცხადი.
ასე რომ, თუ გსურთ მართოთ მტევანი კვანძების,
მტევანი კონტეინერების, შედგენა და Swarm არის გზა წავიდეთ შესახებ.
>> და რა თქმა უნდა, მას გააჩნია Docker ძრავის და Kitematic,
რომელიც ამ დესკტოპის GUI.
მე უნდა აღინიშნოს Docker რეესტრი, რომელიც არ შედის ცვლილებები,
მაგრამ ეს არის გზა, რომ თქვენ თქვენი საკუთარი რეესტრის Docker სხვადასხვა მოსწონს Docker
ცენტრი, მაგრამ შეგიძლიათ უბრალოდ გამოიყენოთ Docker ცენტრი, როგორც გზა უნდა გააკეთოს, რომ.
>> და, ნაკვეთი ირონია, თქვენ ხედავს მას გაშვებული კონტეინერში.
და ასე ჩვენ გავრცელებისათვის სლაიდები.
მთელი ეს პრეზენტაცია რეალურად HTML slide deck.
და ეს არის გაშვებული კონტეინერი, რომელიც შეგიძლიათ მიიღოთ by--
>> NICOLA KABAR: დიახ, ასე რომ გაშვებული სრული დრო ჩემს მაქს.
და მე წარდგენის იგი.
და მხოლოდ ამის Docker შემდეგ თქვენ დააყენოთ თქვენი ცვლილებები.
თქვენ არ შეგიძლიათ უბრალოდ docker პერსპექტივაში და კიდევ ის, და გამოიყენოთ სლაიდები.
>> MANO აღნიშნავს: და ეს არის ის.
ასე რომ, ჩვენ მადლობა მობრძანებისთვის.
და ჩვენ ბედნიერი უპასუხოს კითხვებს.
უნდა აღვნიშნო, სანამ ვინმე ტოვებს არსებობს მაისურები იქ.
ბოდიში ყველას, ვინც უყურებს ამ Livestream ან ვიდეო,
მაგრამ ჩვენ გვაქვს Docker მაისურები იქ.
და ჩვენ ვიცით, Docker სტუდენტები, და ჩემი გამოცდილება,
პროფესორები ძალიან, როგორც თავისუფალი ტანსაცმელი.
>> ასე რომ, მადლობა ყველა გამოდის.
და მიყევით us on Twitter თუ გსურთ, ან არ.
მე არ მაინტერესებს.
ასევე დაიცვას Docker on Twitter.
სწორედ ასევე საინტერესო.
და მაშინ, რომ ეს არის ის.
Docker.com.
გმადლობთ.
>> [ტაში]