Gyakorlati web alapú mély tanulás és biztonság példaként Harmadik kiadás Charlotte Harper 2024. július 3. Frissítve/átalakítva 2025. június 3 -án

Előszó:

A webes fejlesztő tervének és végrehajtásának fontos részét képezi a webfejlesztő tervének és végrehajtásának fontos részét képező biztonsági szempontok, miközben egy megbízható, stabil és gyakorlati célokra hasznos prototípust terveznek. A DOM (Dokumentumobjektum -jelölés), a HTML, JavaScript és CSS megvalósításával, valamint a Python, a C/C ++, a Java és a Bash bevezető háttér -szoftvereivel a webfejlesztőknek a szabadságot és az erőt adja meg a kreativitás, valamint a felhasználó számára, valamint a felhasználót, valamint a felhasználást, valamint a felhasználást, valamint a felhasználást, valamint a felhasználást, valamint a felhasználást és a kényelmes szolgáltatást nyújtó szolgáltatást nyújtó projektek létrehozásához, valamint Idő megölése vagy az interneten való elvégzés megölése, általában egy érintőképernyős okostelefon -eszközön. A legtöbb ember még azt sem tudná, hogy hol kezdje el, amikor egy weboldalt a semmiből akarnak építeni, hajlamosak egy másik ember weboldalán kezdeni, és valami korlátozott funkciót, megbízhatóságot, könnyű használat és különösen a kreativitást építeni, ha rendelkezésre állhattak volna a legfrissebb eszközök rendelkezésére álló legfrissebb eszközökkel, hogy valami hasznos lehetőséget pazaroljanak, és különösen pazarolják a pénzfizetéseket a szoftverekhez szükséges szoftverek számára, és mindenképpen felhasználhatják a felhasználást, és a rugalmasságot. Ha van néhány perce, hogy elolvassa ezt a könyvet, és megtanulja, mit szeretnék megtanítani, vagy akár személyesen beszélni velem a céljairól, és kaphat néhány útmutatást a helyes irányba, és motiváltak arra, hogy megtanulják a kódot és a saját szoftverét írni, vegye haza, és tegye félre, hogy megtanulja a következő befolyásos, erőteljes, streaminált és fontos webalkalmazást, egy olyan weboldalt, amely mindennel szól, és azt, hogy mire vágyik, és megismerheti a közönség igényeit.

Rólam: Szoftverfejlesztő vagyok, széles körű tapasztalattal rendelkezik a C/C ++, a Java, a Python, a HTML, a CSS és a JavaScript területén. Olyan webhelyeket építek, amelyeket az emberek használni akarnak, meglátogatni akarnak, sőt függetlenül attól is, hogy csak megtanulják, újjáépítsék és megöljék az időt, és ami a legfontosabb: a szoftvert értékesítem. Ha volt egy ötlete, hogy pontosan hogyan szeretné, ha egy weboldalt szeretnének megnézni és működni, hajlandó volt támogatni engem, hogy kielégítsem a saját igényeimet, miközben megfelelek a tiédnek, és hajlandó fedezni a weboldal futtatásának költségeit, felépítenék neked a következő YouTube-ot, a Tiktok-ot, a Twitter-et, a Google-t, vagy akár egy olyan csúcstechnikai biztonsági alkalmazás, amelyet csak hozzáférhet. Ahelyett, hogy megpróbálnám eladni az időmet, megpróbálom megvásárolni a tiédet: Szeretnék beszélni egy alkalmazás (weboldal) felépítéséről a már létező információkkal, és megtanítom, mire van szüksége független szoftverfejlesztőnek, vállalkozónak, és sikeres karriert vezet a kívánt területen. És hadd tisztázzam, az oktatás, amelyet adok neked, informális lesz. Mehet az iskolába, és mindezt formális oktatással megtanulhatja, vagy akár elolvashatja ezt a könyvet az iskolában, teljesítheti a feladatait, és sokat elvonhat az oktatásból, de hivatalosan nem teszek téged a forró ülésre, és megkérem, hogy töltse ki a feladatokat. Nem vagyok a professzorod, úgy gondolhatsz rám, mint egy barátom, aki a saját személyes sikere által vezetett karrier felé akar vezetni. És én sem adom el a sikert, akkor meg kell vásárolnia az idejével. A kódolás megtanulása meredek tanulási görbével rendelkezik, és soha nem volt könnyű, vagy akár állítólag is. Annyira keményen kell dolgoznia, amennyire csak tud, és továbbra is megpróbálja a kudarcot, és próbálja újra, még akkor is, ha csalódott, hogy megtanulja és felépítse az alkalmazásokat. Ez maga a kód természetében van. A kódot egy olyan fordító üzemeltet, amelyet úgy terveztek, hogy a programozó hibaüzeneteket adjon, és ezek megtanítják, hogyan kell kódolni, még akkor is, ha egyszerűen a hibát másolja a keresőmotorba, és olvassa el más emberek példáit. És azt kell mondanom, hogy nem kell rendkívül gazdagnak, okosnak, sikeresnek, vagy akár részletközpontúnak vagy szervezettnek lennie egy alkalmazás felépítéséhez. A számítógép gondoskodik az Ön számára a szervezetről. Csak ki kell tartania a tárgyalást és a hibát, meg kell őriznie a figyelmet, és keményen kell dolgoznia azon, amit csinál, és nagyon sikeres karrierje lesz az egészben.

Ki vagyok: Rájöttem, hogy az utolsó szakasz inkább a tanulásról szól, és a könyvről szól. Ki vagyok pontosan? Ez egy bonyolult kérdés. Nem vagyok világos, hogy magam, mivel olyan egészségügyi állapotoktól szenvedek, amelyek megnehezíthetik számomra a kódot vagy a könyvet időnként is, miközben kihívásokat jelentenek a szocializációval és az identitással kapcsolatos kérdésekkel, amelyek megnehezítik az életem, amikor bemutatom magam. Röviden: ha elolvassa ezt a könyvet, akkor hazahozta, mert átfordult rajta, és azt gondolta, hogy hasznos, vagy akár akkor is, ha csak ilyen messzire olvastam, nekem olyan gondolkodású egyén vagyok, aki azt akarja látni, hogy sikerrel jár mindenben, amit csinálsz. Mérnök vagyok, szoftverfejlesztő és hallgató, és ezt a könyvet írok más hallgatók számára, akik megkönnyítik az életüket azáltal, hogy kézikönyve van a szoftverről, amelyre szükségük van az életükre, azáltal, hogy olyan példákat adnak, amelyek egy nagy puzzle -ként illeszkednek, mint egy hasznos, nagy, funkcionális, koherens és vonzó alkalmazások, amelyek a sikert eredményezhetik, függetlenül az üzleti vonalon. Nagyrészt ezt csinálom: olyan alkalmazásokat építek, amelyek segítenek magamnak és más embereknek a sikerhez. Én is szerző vagyok, bár ez az első kiadványom, amelyet befejezek annak érdekében, hogy a portfóliómat hasznos dokumentumba tegyem, és én is művész vagyok. Ezt beismerem neked, egyfajta furcsa ember vagyok. Nem vagyok tökéletes, a törvényekkel együtt vezettem, még arra is, hogy elhagyjam a főiskolákat és az egyetemeket, és elhagyjam az államokat, hogy megpróbáljak magamnak nevezni magamnak, több sikerrel. Születés szerint nő vagyok, sminket viselek, fényképeket készítek magamról, ruhákat és más női ruházatot viselek, és természeténél fogva tudatában vagyok magamnak, mint nőnek. A múltban problémák merültek fel más emberekkel, amelyek küzdelemhez vezetnek a WebApps írásával és felépítésével, és elnézést kérek, hogy nem tudtam hamarabb ezt a könyvet a kezedbe helyezni: szüksége volt erre. Olyan kódot szeretne olvasni és írni, amely úgy néz ki, mint az enyém, és úgy működik, mint az enyém, és ugyanazt csinálja, de még jobb, mert ha megengedheti magának, hogy megvásárolja ezt a könyvet, ahelyett, hogy a billentyűzetet összecsomja, mint én, csak hogy egy könyvet hozzon létre, hogy pénzt kérjen, akkor rendelkezzen az erőforrásokra, amelyekre szükség van ahhoz, hogy sikeres legyen az életében. Mindenféle kérdésem volt a család felnövekedésével, az egészségi állapotokkal, az orvosokkal, a médiával és a törvényekkel, és kódom mélyen tükrözi a feminizmus és a női természet közötti küzdelmet a megosztott és csalódott világban. Ez a könyv azonban mélyen érdekel, a babám, a portfólióm és a megélhetésem, ezért nagyra értékelem a megfontolását, amikor a szöveget hazaéri, és óvatosan átadja azt, hogy tőlem tanulhasson. Kérjük, ne feledje, hogy nem vagyok tökéletes, ennek a könyvnek hibái, felülvizsgálatai és új kiadások lesznek, és a lehető legjobban gondolkodni kell a logikus agyaddal, hogy sikeres tapasztalattal rendelkezzen az írásom során. Ezenkívül értsd meg, hogy jól gondolok neked, még akkor is, ha az írás során kihívásokkal szembesülsz. Gondoljon rá így: Ha csak számítógépes rendszert bérelhet, hogy bármit megtehessen, amit el tud elképzelni a digitális térben, tárolja az összes információt, elemezheti és megszervezi, és megértse azt, akkor elkerülhetetlenül nehézségekkel szembesül az általad elnyelő információkkal és akár közzétételével. Ezt mondom neked, mert ugyanazokkal a nehézségekkel szembesülek. Használja ezt a könyvet a saját felelősségére, működjön együtt a közösségével és a közösségekkel, hogy biztonságos környezetben szoftvert építhessen, és ne vegye be a dolgokat személyesen, ha kudarcot vall, vagy akár rossz módon is sikeres: így jutottam el ezt a szöveget, és miért hozhatom neked ezt a szöveget, és segíthetem Önt, hogy a Global Scale -nek köszönhetően az őrültség elterjedése elterjedt, és a hálózaton keresztül a Global Scale -nál a globális skálán, amely a Global Scale -t, a Global Scale -t, a Global Global -tól, amely a Global Scale -nek köszönhetően, akkor megsemmisült, és megsemmisült. Működni fog, az internet. Lehet, hogy nem ismeri nagyon néhány szóval, hogy ki vagyok, de arra buzdítom, hogy olvassa el, megismerkedjen engem, miközben folytatja és megért engem, miközben saját projektjeit készíti, hogy befejezze a munkáját. Nem lesz házi feladat ezzel a könyvvel, mindaddig, amíg a professzorok vagy a tanárok nem rendelnek hozzád, de nagyon bátorítom, hogy készítsen egy projektportfóliót, ahogy olvassa el, valamint egy Capstone projekt, amely bemutatja, hogyan alkalmazhatja azt, amit megtanult. A Capstone -projektem az alapja annak, amit a könyvben elolvasni fog, mivel magában foglalja a korábbi projektjeim kódját, az általam létrehozott kódot, és megtanultam, hogy módszeresen írjak, és olyan ötletek és tippek széles skáláját, amelyek segítettek abban, hogy sikeresek legyenek, amikor egy egyszerű alkalmazást fel tudok fordítani, és úgy néz ki, mint egy népszerű alkalmazást, amelyet egy népszerű alkalmazás, amelyet a barátod vagy a család használhat, az interneten keresztül, vagy a híreket, vagy úgy néz ki, mint egy népszerű alkalmazás, amelyet a barátja vagy a család használhat, vagy a barátod, vagy a családot használom, vagy a hírek, vagy a hírek, vagy úgy néz ki, mint egy népszerű alkalmazást, amelyet a barátod vagy a család használhat.

Mi ez a könyv: Ez a könyv példaként bemutató bemutató. You can find code here, instructions for how to learn to code, information on debugging code and fixing errors, troubleshooting steps, instructions on how to back up and save your code, re-deploy if anyone breaks your code, secure your code, deploy your code, build interactive websites that are entertaining, engaging, and addictive, and you will get a sense of who I am, why this is important, and how to portray yourself, your app and company image, as well Mint az a szoftver, amelyet az abszolút legjobb fényben épít fel, hogy a lehető legvonzóbb legyen a végfelhasználók, a webhely látogatói számára. Ebben a könyvben számos példát mutatok be a szoftvertervezésre, az interneten, mint a platformon és a biztonsághoz összpontosítva. A tanulási élményt egy alapvető projekt felépítésével kezdeményezzük a Unix Shell segítségével, biztonsági másolatokkal és szkriptekkel. Ezután megvizsgáljuk egy alapvető blog weboldalt, frissítjük blogunkat fotó- és videofunkciókkal, valamint ezeket a funkciókat használjuk biztonsági megoldások alkalmazásához ingyenes szoftver használatával, és a szerverünket egy Pluggable Authentication Module (PAM) segítségével biztosítjuk. Ezután áttekintjük a fájlkezelést és a feldolgozást, a videószerkesztés, a hangadományozás, a vonalkód -szkennelés és az optikai karakterfelismerés feltárását. Mindeközben megvizsgáljuk az API -kat, amelyek segítenek abban, hogy szoftverünket hasznosabbá és biztonságosabbá tegyük, ingyenes és fizetett lehetőségekkel. Útközben felfedezzük a fizikai biztonságot és a militáns eszközöket, például a lőfegyverek és a lőszerek tervezését és gyártását, beleértve a hordó- és ismétlődő kialakítást, a tornyot és a dróntervezést, valamint más alapítókat, akiket a meglévő hálózatba integrálunk a szoftverekbe a szoftverek védelme, valamint az önvédelem és az újreszület bizonyítása érdekében. Szünetet tartunk a játékok, a 2D és a 3D -s megjelenítő motorok felépítéséhez, és beágyazott hardverrel dolgozunk az alapvető dimenziós megjelenítő szoftverek és a szilikon gumiban öntött elektronikus vibráló masszírozók esetében. Útközben olyan gépi tanulási megoldásokat is alkalmazunk, amelyek már rendelkezésre állnak a szoftverek jobb biztonsága érdekében. Az internethez rendelkezésre álló részvényeszközöket is alkalmazunk a folyamat korszerűsítése és biztosítása érdekében. Ez a könyv útmutató a webes alkalmazás felépítésében és a számítógépes és beágyazott mechanikus rendszerek professzionális hálózatával való integrálásának sikeréhez, valamint a szoftverek és beágyazott hardverek létrehozásához, amelyek nélkül nincs háttér -ismeret vagy korábbi tapasztalat.

Amit ez a könyv nem: Ha valóban szeretne egy weboldalt, akkor beállíthat egy egyszerű áruházat, és eladhatja azt, amire szüksége van, blogot küldhet, fotókat vagy videókat küldhet, vagy más módon, anélkül, hogy egyetlen kódot írna. Ez a könyv nem az. Ez a könyv megtanítja, hogyan lehet hasznos, teljesen kiemelt, funkcionális és biztonságos szoftvert építeni, mint bármelyik már megtalálható szoftver, mivel a legfrissebb szoftvert, amely továbbra is prototípusokat tartalmaz, drága lehet, ha olyan méretarányú vállalkozásokon működnek, és nem vonzza a visszamenőleges társaságokat, hogy úgy álljanak, hogy pénzt keressenek olyan emberek számára, akik nem igazán csinálnak semmit. Ha szorosan követi ezt a könyvet, akkor kódot, kutatási kódot kell írni, saját alkalmazásokat készíteni, és pénzt fog keresni, amit csinál. Pénzt fogok keresni ebből a könyvből, még a korai szakaszban is, mert olyan információkat tartalmaz, amelyekre az embereknek szüksége van és el akarnak olvasni, és már vásárolnak, amikor vásárolnak vagy használnak alkalmazásomat. Ez a könyv nem épít fel egy alkalmazást az Ön számára, de a helyes irányba mutat, és a szükséges eszközökkel, valamint a készségekkel és tippekkel, amelyek megkönnyítik a saját sikerét az interneten történő szoftverépítésben, minden kódsorral, amelyet példaként kell írni, készen állnak arra, hogy az interneten és az Ön támogatóinak, és támogatóinak, és támogatóinak, és támogatóinak, és támogatóinak és támogatóinak, és támogatóinak, és támogatóinak, és támogatóinak, és támogatóinak, és támogatóinak és támogatói számára való összeillesztését kell készítenie.

Amit megtanulsz: Ez a könyv megtanítja, hogyan lehet szoftvert, igazán funkcionális, hasznos szoftvert, médiafelvételt, biztonsági funkciókat, például arcfelismerést, gépi olvasható zóna -vonalkód -szkennelést, webes API -kat a videó és a fényképek, valamint a Bluetooth és a közeli mező (NFC) kommunikációjának hitelesítésére, rögzítésére és megjelenítésére. Ez a könyv megtanítja, hogyan kell hálózati számítógépet használni, a Debian Linuxra összpontosítva, hogyan kell felépíteni a bash -kódot, hogy a szoftver telepítését és biztonsági másolatát zökkenőmentes, automatizált szellővé tegye, hogyan készítsük el a Python -kódot háttérképként dinamikus üzenetek kiszolgálására, stílusos dolgokra a CSS -stílusokat használva, a Bootstrap -hoz, az ajánlati szolgáltatásokhoz, például az Interaktivitásokhoz, például az Interaktív Médiákhoz, más internetes szolgáltatásokhoz, másképp, például a Hálózatokhoz, a Hálózathoz, a Hálózathoz, a Hálózathoz, a Hálózathoz, a Hálózathoz, a Hálózathoz, a Hálózathoz, az Interaktivitáshoz, az Interaktivitáshoz, a Hálózati Fjektálásokhoz, az Interaktivitásokhoz, vagy az interaktivitáshoz, vagyis az interaktivitást használja az interaktív eszközökhez Egyéb célok, azonosító szkennelés, kép- és video -moderálás, adatmikrotranzakciók a szoftver biztonságának megőrzése érdekében, a fizetés feldolgozása, a kriptovaluta kereskedelme, aszinkron feladatok és még sok más. Megtanulja, hogyan lehet saját Bluetooth -eszközöket felépíteni akkumulátorokkal, töltőkkel, mikrovezérlőkkel, áramkörökkel, motorokkal és érzékelőkkel, forrasztó, huzal és 3D nyomtatott, valamint öntött anyagok felhasználásával. Bemutatom a 3D -s tervezési igazgatókat, akik alkalmazzák az adalékanyag -gyártást, a szerszámot és a szerszámkészítést, így saját beágyazott, hardverkészülékeket készíthet integrált akkumulátorokkal, töltőkkel, elektronikus áramkörökkel és funkcionális kimenetekkel. és hálózatba lépjen a Bluetooth és az internet segítségével. Pontosabban, két esettanulmányt, egy vibráló masszírozót és egy házi készítésű lőfegyvert fogunk megvizsgálni, mindkettőt az OpenSCAD -ban programozva, amely grafikus felületként vagy parancssori segédprogramként érhető el, és integrálható egy webbe a gyorsabb eredmények érdekében. Megtanulhatja, hogyan lehet egy weboldalt felépíteni és telepíteni az alapoktól kezdve, korábbi tapasztalatok nélkül, funkcionális, biztonságos, gyönyörű, hasznos és ami a legfontosabb, praktikus. Megtanulja, hogyan lehet használni a gépi tanulást és a számítógépes látást egy webhely biztonságának és praktikusabbá tételéhez, a videó és audio rögzítéséhez, adományozhatja a hangját, zenét készíteni és a hangot modulálni, hogy hasznos mintákat hozzon létre, és hogyan lehet áttörni a zajt más webhelyek kialakításával, hogy a lehető legjobb webhelyeket hozza létre, amelyeket közvetlenül a sajátodhoz lehet összekapcsolni, hogy megosszák az összes hasznos információt, és még fontosabbá váljanak a szoftverekhez és az üzleti vállalkozáshoz. Ez a könyv a leginkább a média, a biztonság és a gépi tanulásra összpontosít, amelyek a legfontosabb három összetevő, amelyek segítenek a hasznos szoftverek felépítésében az internet számára, a megfelelő felhasználók bevonásával és a rosszak kikapcsolásával valósághű, praktikus, kézzel és vonzó módon, miközben automatikusan és erős. Ez a könyv az UNIX, a Debian (Ubuntu), a Bash Shell, a Python, a HTML, a CSS, a JavaScript és számos hasznos szoftvercsomagot tanítja a Pythonhoz hasonló kérésekhez, valamint olyan hasznos bash szoftvereket, mint a GIT és az FFMPEG. Azt is megtanítom, hogyan kell automatikusan kereskedni a kriptovaluta, és fizetni kell a kriptovalutában vagy a szokásos betéti kártyákból, miközben még a látogatóinak egy részét kifizetem a bevételeiből, ha úgy dönt. Megtanítom, hogyan lehet pénzt keresni a webhelyről a hirdetésekkel is, hogyan készítheted az alkalmazást a keresőmotorokhoz, és gyorsan rangsorolhatják az első rangsorban, amit az ügyfelek keresnek, hogy megtalálják Önt, és a lehető legtöbb általános keresésben rangsorolják. Megtanítom, hogyan kell eladni a szoftvert, hirdetni, vonzza az ügyfeleket, akik keresik a szolgáltatásait, és megnevezem magának az interneten a már létező utakon keresztül, olcsók és jól működnek. Megtanítom, hogyan mentheti az Ön adatait az Ön számára működő felhő számítógépeken, és olcsón menti az adatait, hogyan lehet megtervezni és felépíteni egy olyan weboldalt, amely megteszi azt, amit a felhasználók akarnak, és mit akarnak, és hogyan tartsa be a felhasználókat azáltal, hogy a webhelyet érintse meg a telefonjukra az értesítésekkel, e -mailben, szöveges üzenetekkel és több lehetőséggel, hogy a felhasználókat az Ön rendelkezésére álló elem mögött tartja, csak az Ön számára rögzített gombnyomással. Ez a könyv a média nagy mennyiségben történő közzétételének és terjesztésének praktikusságára összpontosít, a szövegtől a fényképekig a videókig, az audioig, jó benyomást keltve a végfelhasználókra (az ügyfélkör), és bármilyen módon eladja magát egy weboldal létrehozásához, egy olyan alkalmazást, amely csak Önre és csak Önre reprezentatív, és készít téged, a szoftvered és a vállalata a lehető legjobb módon jól néz ki. Megtanul néhány tippet és trükköt tőlem, a kódolási tippekből, a gyakorlati hiúságból, például a sminkből és a fotózásból, a modellezésből és a színészkedésből, és még sok más, amelyek fontos lesznek a lehető legjobb fényben, a rendelkezésre álló szerszámok felhasználásával, a lehető legjobban történő ábrázoláshoz, amennyire szükség van a platformok egészséges egyensúlyának elosztásakor, több erőfeszítéssel, vagy pénzre, vagy pénzre, mint a pénz, mint a pénz. Ezt a könyvet "praktikusnak hívjákWeb alapú mély tanulás és biztonság példa: "Okból: a kódolás megtanulásával foglalkozik, kifejezetten az interneten, különös tekintettel a biztonságra összpontosítva, gyakorlati szempontból, a működőkód példáival, amelyek a szövegben vázolt gyakorlati célokat szolgálják. A szöveg felismerése és a videofelvételi képek, a képmodalom, a képmodalom, a képek, a képek felépítését, a kódot, a kódot, a kódot, a kódot is megmutatom, hogyan kell futtatni, hogyan kell futtatni a számítógépet, a számítógépes megjelenítést és a video -moderációt, a kódot, a kódot. A továbbfejlesztés, a kép felirata és más feladatok, például a képekből származó predikciós mutatók, mint például a kép, mint hiteles, számítógépes kép, vagy optikai másolat (egy kép fényképe, vagy nyomtatott fénykép), akkor a gépi tanuláshoz nagyon fontos, ha a szoftverek biztonságát használják, ha a számítógépes naplózást használhat. Az arca. felhasználás). Bárki, aki kifogástalanul biztonságos szoftvert épít fel, van valamilyen értelme, hogy mit jelent ez. A szoftver természetéből adódóan bizonytalan, mivel azok az eszközök és fiókok, amelyeket hozzáféréshez használunk, nem mindig állnak rendelkezésre, hanem bárki kezében lehetnek, aki rosszul szándékozik a szoftverre, és ezért magának a szoftvernek kockázatot jelenthet. Ez a könyv középpontjában. A hálózatba kötött számítógépet alapértelmezés szerint egy hosszú kulccsal, amelyet egy hosszú kulccsal hívnak, és az SSH vagy a Secure Shell kulcs, és egyébként a legjobban rögzítve egy webszerverrel, mert a webszerver biztosítja a nyitott hozzáférést, valamint a kiszolgálón futó művészeti biztonsági eszközöket. A webszerver hozzáférhet a felhasználó webes böngészőjéhez, amely vitathatatlanul a felhasználó eszközének legerősebb része, mert ez az a hely, ahol a felhasználó hozzáférhet a hálózati szoftverhez. Ez az eszközkészlet szöveget, a látott weboldalakat, valamint képeket, audio és videót is rögzíthet (például egy arc vagy egy állami azonosító fényképe), olvashat és írhat a Bluetooth rádió eszközökre, és olvashat és írhat a közeli terepi transzponder címkékre, olcsó kulcskártyák, fobok, matricák, gyűrűk és még a chip -szerver, az egyedi soros számokkal, amelyek leolvashatók. Az összes rendelkezésére álló eszköz felhasználásával, ezzel a könyvvel felszerelheti magát egy biztonságos weboldal felépítéséhez, és összességében egy biztonságos hálózati számítógépes rendszert, amely az Ön számára működik, megteszi az ajánlattételét, és megjelenik és érezte magát

Hol kezdjem: Üdvözöljük, hogy kihagyja azt a szakaszot, amelyben ezt a könyvet vagy bármely szakaszban elkezdem a pontos kódot, különösen, ha tapasztalata van a kódolás előtt vagy a fent említett eszközök bármelyikében, amelyet részletesen leírok ebben a könyvben, valamint dokumentálom a felhasználási eseteket és azok gyakorlati példáit. Ha nincs tapasztalata a kód írásában, nagyon ajánlom, hogy olvassa el az összes könyvet, és különösen azt javasolja, hogy olvassa el az előző szakaszokat, hogy megbizonyosodjon arról, hogy ez a könyv megfelelő -e az Ön számára. Ha ez a könyv nem felel meg az Ön számára, fontolja meg az ajándékozását egy barátnak vagy rokonnak, aki érdekli a webfejlesztés megismerése, és még fontolóra veszi a kölcsönvételt, és megtanulja tőlük, hogy kitöltse a hiányosságokat, ahol kudarcot vallott, mint tanár, vagy más tanárok, akik előttem tettek. Kezdje el, ahol a könyv minden része hasznos lesz, ha hasznos alkalmazást kíván felépíteni, és fontolja meg, hogy a legjobb alkalmazásokat a végfelhasználó szem előtt tartásával építik fel: Ismerje meg az ügyfelet. Most már ismersz, ismered ezt a könyvet, és készen állsz a kezdésre. A kezdéshez ragadjon meg egy számítógépet (még a legolcsóbb laptopot is a dobozboltból, az Amazon -ból vagy egy régi asztali művekből, és állítsa be az Ön számára megfelelő módon.

Hogyan olvassa el ezt a könyvet: A kiemelt szöveg azt jelzi, hogy a szöveg egy parancssorba tartozik, ahol megírja a futtatott kódot. A parancssor erősen billentyűzetre fókuszált, és kevés vagy nem igényel kattintást, felgyorsítja a munkafolyamatot és megkönnyíti a dolgokat.

Az indulás: Merüljünk be. Kelépítjük a kódot egy helyi gépen, és elindulunk anélkül, hogy az internethez csatlakoztatott weboldalt építenünk. Ezt biztonságosabb kezdeni, semmit sem fizet, és könnyű. Az operációs rendszertől függően a bash héjba való belépés kissé más lesz. A Mac OS esetében azt javaslom, hogy telepítsen egy virtuális gépet ezen a ponton, mivel a legnagyobb kompatibilitást kapja egy virtuális géppel. Különböző szolgáltatók, mint például a VirtualBox és a Paralells, futtathatnak egy virtuális gépet az Ön számára, bár az Ubuntu -t közvetlenül a gépre is telepíthetik, ha inkább olyan natív környezetet használ, amely ajánlott egy gyors, ésszerű élmény létrehozása érdekében. Ha Linuxot vagy Windows -t használ, amit ajánlom, akkor meglehetősen könnyűnek kell lennie egy projekt létrehozása. Nyissa meg a terminálját, állítsa be a méretezést, ahogy látja, és kezdje el a 2. lépést. Ha Windowsot használ, kérjük, kövesse az 1. lépést.

1. lépés: - Csak a Windows felhasználók A Windows -ban nyissa meg a parancssort adminisztrátorként és írja be WSL –Install

2. lépés: - Folytassa itt, vagy hagyja ki az 1. lépést, ha nem használja a Windows -t Egy nyitott terminálban (az operációs rendszertől függően, az Ubuntu -nak a Windows -ban, a Mac vagy a Linux terminál, vagy a hasonló név) kezdje el egy projekt létrehozásával. Ezt megtesszük az MKDIR paranccsal, amely létrehoz egy könyvtárat. Ha létrehoznia kell egy könyvtárat, amely az ajánlott projekt tárolásához, akkor a CD parancs segítségével változtasson a könyvtárra és

CD/elérési út//könyvtár - Az elérési út a rendeltetési könyvtárat megelőző mappák (fájlok), az alapértelmezett elérési út ~ vagy/otthoni/felhasználónév (ahol a felhasználónév a felhasználónév). Az alapértelmezett könyvtárra való váltáshoz írja be a CD -t vagy a CD ~ -t MKDIR példa - Cserélje ki a "példa" -t a könyvtár nevére

Most van egy munkakönyvtár a projektjéhez. Mivel annyira fontos, hogy ezt a könyvtárat elmenti, ha át kell váltania egy másik gépre, vagy telepíteni kell az írott kódot, hogy készen álljon az internetre, egy szkriptet készítünk a könyvtár biztonsági másolatához a következő néhány lépésben. De a szkript felépítése egy kis kódot vesz igénybe, és a kódot automatizálni kell, hogy a lehető leghasznosabb legyen. Tehát készítsünk egy szkriptet a szkriptek készítéséhez. Kezdjük a szkript létrehozásával és végrehajthatóvá tételével. Ehhez használjuk a sudo, a chmod és az érintés, és a szkriptet "Ascript" -nek hívjuk.

sudo touch /usr/bin/ascript
sudo chmod a+x /usr/bin/ascript
sudo nano /usr/bin/ascript

Most létrehoztuk a szkriptet, végrehajthatóvá tettük és készen állunk a szerkesztésre. A Nano egy szövegszerkesztő, amely lehetővé teszi a szöveget kattintás nélkül, ami sokkal könnyebb, mint a grafikus felhasználói felület használata. A fájl Nano -val történő szerkesztéséhez használja a Nano -t, majd a fájl elérési útját. A szkript készítésének szkript készítéséhez ez meglehetősen hasonló a szkript készítéséhez. Ugyanazt a kódot használjuk, mint a fenti, a "Ascript" szkript nevét egy argumentumparaméterrel, 1 dollárral cseréljük. Ez lehetővé teszi a szkript felhívását az egyszerű Sudo Ascript Newscript beírásával, ahol bármilyen új szkriptet létrehozhatunk a "Newscript" helyettesítésével a szkript nevével. A Nano -kódnak a következőnek kell lennie:

sudo touch /usr/bin/$1
sudo chmod a+x /usr/bin/$1
sudo nano /usr/bin/$1

A Nano bezárása érdekében visszatarthatjuk a vezérlőgombot, és megnyomhatjuk az X -et, majd az Y -t, hogy jelöljük, hogy elmentjük a fájlt, és eltaláljuk a visszatérést. Most ahelyett, hogy beírnánk ezt a három parancsot egy szkript szerkesztésére, képesek leszünk beírni a SUDO AScript AScript -t a szkript újbóli szerkesztéséhez. Ez működik! És minden új szkript könnyen futtatható, ha a héjba hívja. Mentsük el most a munkánkat: Írjunk be egy biztonsági mentési szkriptet az új szkript mentéséhez, majd biztonsági másolatunk a Projektkönyvtárban, miközben biztonsági másolatot készítünk a biztonsági mentési szkriptről.

sudo ascript backup

Most, Nano -ban:

sudo cp /usr/bin/backup /path/to/directory/
sudo cp /usr/bin/ascript /path/to/directory/

Hol van a/út//könyvtár az a projekthez, amelyet az MKDIR -rel készített. Később megtanuljuk, hogyan másolhatjuk az ilyen ismétlődő útvonalakat egy hurokkal és egy listával, amely kevesebb kód, de egyelőre tartsuk egyszerűen, és néhány sorral rendelkezzünk. A szkript futtatásához és a kód biztonsági mentéséhez mentse el a fájlt Nano -ba a Control+X, Y, és adja vissza, és írja be az alábbiakat a Shellbe

backup

Ha egyáltalán kéri egy jelszót, miközben elolvassa ezt a könyvet, és követi a Shell-et, kérjük, írja be a felhasználói jelszavát helyesen, három próbálkozás lesz, mielőtt újra kell működtetnie a parancsot. Használhatja a fel és le nyilakat a parancsok újratelepítésére és szerkesztésére, ha bármit kétszer kell futtatnia. Egyszerűen nyomja meg a fel -le szakaszosan egy parancs kiválasztásához, mielőtt a parancsot jobbra, bal nyilakkal szerkesztené, és törölje a billentyűt, valamint a billentyűzetet, és futtassa vissza a visszatéréssel.

Gratulálok! Sikerült létrehoznia egy fantasztikus biztonsági mentési szkriptet, amely biztonsági másolatot készít két fontos shell szkriptet a munkakönyvtárban. Lehet, hogy később mozgatjuk a dolgokat, amikor a projekt egyre nagyobb lesz, de ez most működik. Haladjunk tovább a biztonsági mentésről a felhőben, ehhez a GitHub -ot használjuk (bár számos más GIT -megoldás létezik a biztonsági másolathoz, ezek mindegyike azonos.) A GIT egy Verision Control szoftver, amely lehetővé teszi a szoftver szerkesztéseinek biztonsági másolatát, miközben egy szerverre készíti őket, miközben lehetővé teszi a szoftver teljes példányának letöltését egy jelszó vagy kulcs mögött. Ez fontos a szoftver mentésében, főleg amikor a biztosított Linux példányokra migrálunk, amelyek néha megszakadnak, amikor egyetlen kódsor kudarcot vall, és lezárva hagyja, miközben a kód nem kerül biztonsági másolatra, ha nem kap esélyt arra, hogy automatikusan biztonsági másolatot készítsen, amelyet lefedünk.

Ha ezen a ponton még nem használ Ubuntu virtuális gépet, akkor ajánlom egy Ubuntu virtuális gép használatát ezen a ponton, mert ez megkönnyíti az életét, amikor az összes szükséges csomag telepítéséhez szükséges, hogy egy működő weboldalt és a mély tanulási műveleteket előkészítse a számítógépen. A kódot a közeljövőben áthelyezzük egy webszerverre, de szeretnénk biztosítani, hogy a webszerver mögött legalább néhány biztonsági réteg legyen, amelyek ellenállnak az adathalásznak, és számos Linux -csomagot alkalmaznak. Ha továbbra is szeretné használni a Mac OS -t, szívesen keresi és telepítse a szükséges csomagokat online, de lehet, hogy nincs alternatívák minden csomaghoz, amelyet ez a könyv vagy a sorozat lefed.

Adjunk hozzá néhány parancsot, hogy munkánkat a biztonsági mentési szkripttel elkötelezzük el a Sudo Ascript Command biztonsági másolat futtatásával.

# …

Ismét irányítsa az X -et a megtakarításhoz.

Most egy időpontos konfigurációt kell elvégeznünk ehhez a projekthez. Mivel hamarosan GIT -projekt lesz, nem kell minden parancsot beírnunk minden alkalommal, amikor egy GIT -tárolóból telepítünk, de ennek felfüggesztését kapjuk, amikor a telepítési szkripteket írjuk. A kezdéshez győződjünk meg arról, hogy a megfelelő könyvtárban vagyunk, és inicializáljuk a GIT -lerakatot, és generáljuk az SSH kulcsokat.

cd /path/to/directory
git init
git branch -m master
ssh-keygen

Miután beírjuk az SSH-KeyGen-t, az új kulcsot a otthoni mappába kell menteni egy .ssh nevű mappába. ID_RSA.PUB -nak hívják. Találjuk meg ezt a kulcsot, és másolja. Látni,

cd ~
cat .ssh/id_rsa.pub

Másolja a szöveget, amelyet az utolsó parancs ad vissza, és hozzon létre egy fiókot a GIT szolgáltatójával (ideális esetben a GitHub), mielőtt hozzáadná az SSH kulcsot a fiókjához. Miután van egy fiókja, kattintson a jobb felső menüre, és írja be a beállításokat, mielőtt hozzáadná az SSH gombot az SSH és a GPG kulcsokhoz a menüben lévő hozzáférés alatt. Válassza a SSH gomb hozzáadása lehetőséget, és adja hozzá a sajátját, ha beilleszti, és megadja a címet, mielőtt megtakarítana és visszatér a GitHub -ba, hogy új tárolóhoz hozzon létre. Ez hasonló a többi GIT -szolgáltató számára, el kell olvasnia a dokumentációjukat. Az új lerakat konfigurációban adjon leíró nevet a lerakatának, és döntse el, hogy közzéteszi -e, és feltétlenül konfiguráljon fájlokat a beillesztéshez. Miután a tároló létrehozása után a klónt másolja az SSH URL -vel, és illessze be a következő parancsba.

git remote add git://… (your remote URL)

Most visszatérhet a tárolóhoz a CD -vel, ezt ismeri. Próbálja ki most a biztonsági mentési szkriptet

Nagy! Most valóban kódolhatunk. Telepítsük a Django -t most, hogy jól megragadjuk a bash -ot és a git -et. A Django lehetővé teszi, hogy automatikusan biztonsági másolatot készítsen a szoftverünkről, a Bash ezt is megteheti, de a Django -nak egyszerűbb biztonságosabb megvalósítással kell rendelkeznie (ez könnyebben letiltható és konfigurálható).

A szoftver telepítéséhez az Ubuntu-ban a sudo apt-get parancsot fogjuk használni. Először frissítsük és frissítsük a már meglévő szoftvert. Ez megtehető a sudo apt-get frissítéssel és a sudo apt-get frissítéssel. Ezután telepítsük a Python-ot és a Virtuális Környezetünket, a kód otthonát, a következő paranccsal: sudo apt-get telepítse a python-is-python3 python3-ventv-t

Ez minden, amire szükség van a Django -val való eljutáshoz az Ubuntu példányban történő szoftver telepítések szempontjából. A Windows és a Linux esetében ennek meglehetősen egyszerűnek kell lennie, de a Mac esetében érdemes lehet egy virtuális gépet és Linuxot telepíteni egy ingyenes vagy fizetett virtuális környezet, például a VirtualBox vagy a Paralells asztal felhasználásával, és újjáépítse a fenti lépéseket az Ubuntu környezet beállításához. Az Ubuntu ebben az esetben kritikus fontosságú, mert a szoftver a webhelyek futtatása, és lehetővé teszi számukra, hogy a fent említett szoftverekkel ellátott webhelyeket tárolják.

Ássuk be a djangóba.

Ismét a könyvtárban, a CD -vel:

python -m venv venv # Létrehozza a virtuális környezetet, ahol a kód tárolódik
source venv/bin/activate # Aktiválja a virtuális környezetet
django-admin startproject mysite . # Ahol a MySite az a projekt, amelyet a jelenlegi könyvtáramban kezdtem.

A Django éppen elkezdi minket, mert a Django a webszerver tárolja, és mindent megtesz, amire szükségünk van, hogy egy alapvető helyi weboldalt felállítsuk és működtessék. Most, hogy a Django telepítve van, szerkesszük egy kicsit a beállításokat, hogy ez működjön, ahogy szükségünk van. Először hozzunk létre egy új alkalmazást

python manage.py startapp feed

Észre fogja venni, hogy az első alkalmazást feednek hívják. Az alkalmazást bármi másnak kell hívni, és új alkalmazásokat fogunk létrehozni, de az egyes alkalmazások nevének minden alkalommal következetesnek kell lennie, amikor az alkalmazás hivatkozik a kódban. Egy új alkalmazás hozzáadásához mindig a beállítások.py -t szerkesztjük a másik könyvtárban, amelyet az alkalmazás a StartProject, a továbbiakban az alkalmazásban készített. Nano használatával,

nano app/settings.py

A beállításokban keresse meg a telepített_Apps -t, és válassza el a [] -ot 3 sorba. Négy szóköz felhasználásával az üres középvonalon, adjon hozzá 'Feed' vagy az alkalmazás nevét. A beállítások ezen szakaszának a.py -nek úgy kell kinéznie, hogy:

INSTALLED_APPS = [
    'feed',
]

Mielőtt elfelejtenénk, teszteljük, hogy Django működik. A Python kezelés.py.pherver 0.0.0.0:8000 parancs használatával futtathatjuk a kiszolgálót, majd navigálhatunk a számítógépen lévő böngészőben a kódot a http: // LocalHost: 8000 -re futtató számítógépen, és láthatjuk a Példakénti weboldalt (ez működik!).

Most ássuk be néhány Python -kódot. A Django -nak három fő összetevője van, mindegyiket a kód teljes egészében működteti. Az alkatrészeket modellnek, nézetnek és sablonnak nevezzük, és mindegyik magasabb és alacsonyabb szinten van, mielőtt a weboldalt a felhasználóhoz kézbesítik.

A modell az a kód, amely információkat tárol az adatbázisban a visszakereséséhez, a válogatáshoz és a megjelenítéshez.

A nézet eldönti, hogy a modell hogyan jelenik meg, manipulálva és módosítva, szinte minden nézet közvetlenül használja a modellt.

A sablon a HTML kód, néhány extra haranggal és sípolóval, az úgynevezett sablonnyelvvel. A sablont az a nézet, ahol Python kóddal és kontextusokkal, például modellekkel és információkkal (Usuall karakterláncok és egész számok) tölti be a nézetből.

A Django -nak más összetevői is vannak, ideértve, de nem kizárólag:

Beállítások, amelyek konfigurálják az alkalmazást, amint azt tárgyaltuk.

Az URL -ek, amelyek olyan minták, amelyeket a felhasználó követ, hogy hozzáférjen a webes alkalmazás egyes részein.

Az űrlapok, amelyek meghatározzák, hogy a szerverre küldött információkat hogyan kezelik, és az adatbázisba, valamint a felhasználóba továbbítják. Ez az alapja a kiszolgáló oldalán feldolgozó információk feldolgozásának, és bármilyen típusú információt elfogadhat, amelyet a számítógépes üzletek, nevezetesen a szöveges karakterláncok, a számok és a valódi/hamis logikai (általában jelölőnégyzetek).

A sablonok, amelyek HTML kód és sablon nyelv, és áthidalják a rést a Python és a HTML között, azaz a Python -információk HTML -kódként szolgálhatnak, amelyhez bárki hozzáférhet, és korlátozott hozzáféréssel biztosíthatja a weboldalt, miközben a Python -kódot az interneten való hozzáférhetővé teszik, és hasznos a távoli eszközön, amelynek nem kell a szerver közelében lennie.

Statikus fájlok, amelyek általában JavaScript és könyvtárak, amelyeket a szerver szolgál és kapcsolódik a sablonhoz.

A médiafájlok, amelyeket a kiszolgáló kiszolgál vagy külsőleg tárol, vagy csak a szerverre írja, mielőtt feldolgoznák, és egy másik szerverre (vödör) küldték el a tároláshoz.

A köztes szoftver, amely olyan kóddarabok, amelyek minden nézetben egyidejűleg futnak, és amelyet a nézetbe "tartalmaznak".

Kontextus -processzorok, amelyek feldolgozzák az egyes nézetek kontextusát, és extra kontextus hozzáadására szolgálnak.

Tesztek, amelyek igazolják, hogy a felhasználó vagy kérés bizonyos követelményeket teljesít, mielőtt a nézetet megjelenítik.

A fogyasztók, amelyek diktálják, hogyan kezelik a WebSockets a kommunikációt.

Az adminisztrátor, amelyet a modellek regisztrálására használnak, így a Django admin oldalon részletesen manipulálhatók, ahol az adatbázis grafikus felületen keresztül adható be.

A zeller, amely meghatározza a django kód aszinkron feladatait, elkezdhet futni, mielőtt azonnal folytatná a következő feladat vagy a kód sorát.

A Django -nak sok más összetevője lehet, amelyeket itt részletesen tárgyalunk. Rengeteg módon lehet a Django funkcionálisabbá tétele, és olyan WebSockets hozzáadását, amelyek gyors, egyszerűsített kommunikációs csatornák, zeller, amely aszinkron feladatokat hajt végre, és sok más szoftver a Django kiterjesztésére, különösen a nézet funkcióiban, ahol a legtöbb kódot végrehajtják. A nézetfunkciók kulcsfontosságúak, mivel általában minden olyan kóddarabot deklarálnak, amely egy adott URL -mintára vagy a szerver szakaszára vonatkozik.

Először fedezzük fel a nézetfunkciókat. A nézetfunkciók az importálással kezdődnek, amely jelöli a nézetben használható kódot, és amelyeket a szokásos funkciódefiníciók vagy osztályok alapján határoznak meg. A legegyszerűbb nézeteket a def függvénydefiníció határozza meg, és egy httpResponse -t ad vissza alapsablonnal. Kezdjük azzal, hogy meghatározzuk az alapvető nézetet a "Hello World" szöveg visszaadásához. Ne feledje, hogy minden alkalommal, amikor egy olyan utasítás után, mint a DEF, hozzáadása, ha a def -hez hasonlóan, ha, míg stb., 4 helyet kell hozzáadnia az előző meghatározásokhoz, amelyeket a funkciójára szeretne alkalmazni. Belépünk arra, hogy hamarosan mit jelentenek.

Webhelyünk könyvtárából szerkessze a Feed/Views.py fájlt a Nano használatával, és adja hozzá a következő sorokat a fájl végéhez.

from django.http import HttpResponse

def hello(request):
    return HttpResponse('hello world')

Django HTTPResponse egy szöveges karakterlánccal válaszol, amelyet a nyitó és a bezárás jelöl. Minden alkalommal, amikor az információkat egy funkciónak vagy osztálynak, például kérésnek vagy karakterláncnak továbbítja, zárójel (, megnyitási és bezárás) használatával kell használnia.

Ez még nem minden, amire még nem kell látnunk a véleményünket. Természetesen még nem mondtuk el a kiszolgálónak, hogy a nézet pontosan hol van, még mindig meg kell határoznunk egy utat, amellyel a nézetnek megjelenik. Kezdjük azzal, hogy meghatározzuk az alapvető elérési utat az app/urls.py webhelyen, és később bejutunk az útcsoportokba.

Az App/URLS.PY alkalmazásban adjon hozzá egy sort az importált nyilatkozatok után, miután az éppen létrehozott nézetet behozta.

from feed import views as feed_views

Most határozzuk meg a nézetmintát. A nézetmintáknak három összetevője van, az elérési út összetevője, amely megmondja a kiszolgálónak, ahol a nézet létezik a szerveren belül (az URL elérési út, amelyet a felhasználó a navigációs sávba ír be a weboldalra), a nézet -összetevőt, ahol a nézet van megadva, és egy barátságos név a nézethez, így könnyű megszerezni a mintát, vagy egy másik kilátáshoz, vagy egy másik kilátáshoz, egy másik kilátáshoz. Érdemes, hogy így csináljon dolgokat és rugalmas legyen, mert a kódbázis egy folyamatosan változó környezet lesz, amely rugalmasságot és improvizációt igényel, hogy értékes és könnyen kezelhető legyen. Így fog kinézni a véleményed, ezt hozzáadhatja az urlpatterns -hez = [az app/urls.py szakasz. A nézetmintát a fent leírt három összetevő és az PATH nevű funkció határozza meg. Az URL -minták egy lista, ezért feltétlenül vesszővel végezzék el az egyes elemeket, mert ez elválasztja mindegyiket. Minden elemnek új sorra kell mennie, ismét négy szóközökkel, csakúgy, mint a settings.py alkalmazásban. Meghatározzuk a nézet első összetevőjét egy üres karakterlánc funkcióval, hogy létrehozzunk egy nézetet, amely a webszerver gyökérkönyvtárán fut. Az URLS.Py -nek most így kell kinéznie:

from feed import views as feed_views

urlpatterns = [
    path('', feed_views.hello, name='hello'),
]

Ez az alap az alapja a Django -val, amely teljesen statikus. Annak érdekében, hogy egy dinamikusabb weboldalt készítsünk, ahol megkezdhetjük a gyorsítótárazási információkat, például képeket, videókat, audio -t és még sok más, olyan modelleket kell használnunk, amelyeket a következőkben fedezünk fel. Egyelőre ellenőrizzük a kódunkat és futtassuk a szerveret. A hibák kódjának ellenőrzéséhez futtassa:

python manage.py check

Ha valamilyen hibaüzenetek vannak, gondosan át kell vizsgálnia az alkalmazásban végrehajtott változtatásokat, és ellenőrizze, hogy van -e valami, amit javítani kell, például egy idegen vagy hiányzó hely, egy extra karakter, egy bukott karakterlánc, bármely elírás, bármilyen véletlenül törölt karakter vagy bármi más. Olvassa el a hibaüzenetet (ha van ilyen), akkor látnia kell a létrehozott vagy szerkesztett fájl elérési útját egy sorszámmal együtt, tehát nézze meg a fájlt és a sorban, és nézze meg, tud -e kijavítani valamit, ami ott van. Ha kijavította a problémát, futtassa újra a fenti parancsot. Amikor a szoftver készen áll a futtatásra és a működésre, látni fogja a kimenetet: "A rendszer ellenőrzése nem azonosított problémát." Most már készen állsz a menni. Futtassa a kiszolgálót:

python manage.py runserver 0.0.0.0:8000

Most nyisson meg egy böngészőt, és keresse meg a http: // localhost: 8000 oldalt. Látnia kell a szöveget, amelyet a HTTPResponse funkció zárójelben és idézeteiben tért vissza. Ez csak egy alapvető példa, de ha eddig elérte, akkor megérti a Linux, Bash, Python és Django alapjait. Mélyebben mélyüljünk be néhány adatbázis -modellezést, és fedezzük fel a Python osztály erejét az információk tárolásában. Ezután megkezdjük a HTML -t és a CSS -t, mielőtt a JavaScript és a gépi tanulás használatával teljes mértékben szerepelnénk, rugalmas, rugalmas és biztonságos.

Az osztályokat az alkalmazás modelljeiben tárolják. A Nano használatával szerkessze az app/modelleket.py -t, és adjon hozzá egy új osztályt. Az osztály meghatározása az osztály meghatározásával van meghatározva, és átad egy szuperosztályt, amelyből örököl, ebben az esetben a modellek. Az osztály neve az osztály meghatározása után jön, és az A osztály meghatározása után: (vastagbél), mielőtt az osztályhoz kötött attribútumokat és funkciódefiníciókat az alábbiakban jelöljük. Osztályunknak szüksége van egy azonosítóra, amelyet felhasználhatunk annak visszakeresésére és egyedi megőrzésére, és szüksége van egy szövegmezőre bizonyos információk tárolásához. Később hozzáadhatunk egy időbélyegzőt, fájlokat, logikákat (igaz vagy hamis definíciók, amelyek elősegítik a kódunk döntéseit arról, hogy mit kell tenni a modellel, és felhasználhatjuk annak rendezésére), egy olyan példány, amely a modellt a szerverbe bejelentkezett felhasználóhoz és még sok máshoz köti. Csomagoljuk ki az alábbi kódot:

from django.db import models # Az az import, amelyet az osztályunk meghatározására használnak, és az attribútumok
class Post(models.Model): # Maga az osztályunk meghatározása
    id = models.AutoField(primary_key=True) # Modellünk azonosítója, egy automatikusan generált kulcs, amely lehetővé teszi a modell lekérdezését, az egyedi tartását, és akkor hasznos, ha a modell létrehozása után kölcsönhatásba kell lépnünk a modellel.
    text = models.TextField(default='') # Az osztálytársaink attribútumunk ebben az esetben néhány szöveget, alapértelmezés szerint egy üres karakterláncra.

Zárja be és mentse el a fájlt, ahogyan azt korábban tettük, hogy befejezzük.

Számos más mezőt és lehetőséget fogunk feltárni, amikor ezt az osztályt frissítjük, ahogy az alkalmazásunk fejlődik, de ez az alapvető szükséglet egy alkalmazás létrehozásához, amely egy szöveget közzétesz. Ez a modell azonban nem fog egyedül működni. Mint korábban leírtuk, szükségünk lesz egy egyedi nézetre és egyéni URL -mintára, hogy ez a modell működjön, és egy űrlapra és sablonra is szükségünk lesz. Először fedezzük fel az űrlapot.

Az űrlap meghatározásához szerkessze az app/forsts.py nano -t, és adja hozzá a következő sorokat. Szükségünk lesz két importálásra, az űrlapok osztályára, valamint a létrehozott modellre (feed.models.post), a modellhez hasonló osztály meghatározására, és egy mezővel, valamint egy Meta nevű alosztálymal, amely meghatározza a modellt, amelyben az űrlap kölcsönhatásba lép. Az űrlapnak van egy inicializálási funkciója is, amely a kérelemben szereplő információk alapján állítja be, vagy más módon, ezt később feltárjuk.

A modelli űrlapok annyira hasznosak, mert modellt hozhatnak létre, vagy szerkeszthetnek egy modellt, így mindkettőhöz fogjuk használni. Határozzuk meg egyet az alábbiakban.

from django import forms
from feed.models import Post

class PostForm(forms.ModelForm):
    text = forms.CharField(widget=forms.Textarea)
    class Meta:
        model = Post
        fields = ('text',)

Ez az alapja annak, hogy néz ki egy forma és modell. Ez a modell űrlap felhasználható egy bejegyzés insantálására vagy szerkesztésére, az általa tartalmazott szöveg megváltoztatására. Megvizsgáljuk, hogy ezt az űrlapot integráljuk a következő nézetbe. Először tegyük meg az áttelepítést, és migráljuk az adatbázist, hogy a kódunk kölcsönhatásba léphessen a modellel, amikor fut. Ehhez futtassa a következő parancsokat:

python manage.py makemigrations
python manage.py migrate

Ez egy percet vesz igénybe a végrehajtáshoz, de ha egyszer megtörténik, lehetővé teszi a modell elérését a nézetekben, a köztes szoftverekben vagy a szoftver bárhol másutt. Folytassuk azáltal, hogy megtekinthetjük a modellünket. Szerkessze a Feed/Views.py szerkesztését, és adja hozzá a következő kódot, amint azt megjegyeztük. Nem kell semmit hozzáadnia a # aláírás után, ez a kód olyan megjegyzések, amelyeket a kóddal kapcsolatos információk jelölésére használnak. Kezdjük azzal, hogy importáljuk modellünket a nézetekben, és hozzáadjuk azt egy olyan környezetbe, ahol a sablonban megjeleníthetjük a kijelzőn. Ezután hozzáadunk egy sablont, ahol az űrlapot és a modellt egy gombbal készíthetjük, hogy új objektumot hozzunk létre a modell alapján, és elküldjük a szerverre. Ez bonyolultnak hangzik, tehát tegyük csak lépésről lépésre. Mielőtt befejezzük a nézetet, hozzunk létre egy sablont, amely csak megjeleníti a modellt, és győződjön meg arról, hogy láthatjuk -e egy új bejegyzés létrehozásával a héjban. Így kell kinéznie ennek a nézetnek:

    posts = Post.objects.all() # Kérdezze meg az eddigi adatbázis összes hozzászólását

Mindez nagyon egyszerűnek tűnik, amíg el nem érjük az alját. A megjelenítés, a függvény által visszaadott érték, ahelyett, hogy egy HTTP -válaszhoz hasonlóan az előző példa, mindig kérést vesz igénybe, mint az első bemenetet, elfogadja a kontextust (ebben az esetben az adatbázisban található hozzászólások), amelyet most a sablonban lehet megjeleníteni, és a függvényben meghatározott sablonot adja vissza. A sablon HTML dokumentum lesz, egy kis Jinja2 nevű nyelvvel, amely a Python információkat a HTML -be adja.

A sablonok létrehozásához készítsen két könyvtárat a takarmányban.

mkdir feed/templates
mkdir feed/templates/feed

Ezután szerkessze a sablont a fenti könyvtárban, Feed/Sablons/Feed, és adja hozzá a példát. Nézzük meg a sablonot erre a példára.

Ez egy nagyon egyszerű sablon. Meghatározza a HTML -címkék megnyitását és bezárását, egy dokumentumtípus -címkét, egy legenda címmel ellátott testtagot, egy töréscímkét, amely egy kis sort ad a képernyőn, és egy olyan hurok, amely a hozzászólások listáján szereplő minden bejegyzést a sablon bekezdésének adja. Ez minden, ami a hozzászólások megjelenítéséhez szükséges, de az adatbázisban még nincs. Készítsünk néhányat a héjjal. Futtathatjuk a héjat a kezelés.py segítségével

python manage.py shell

Most importáljuk a postmodellünket

from feed.models import Post

Ezután létrehozunk egy egyszerű hozzászólást egy karakterlánccal, és kilépünk a héjból. A karakterlánc bármi lehet, mindaddig, amíg érvényes szöveg.

Post.objects.create(text='hello world')
exit()

Végül, URL -mintát kell hozzáadnunk a takarmányunkhoz. Mivel a Feed alkalmazásunk több URL -t fog használni, és a fájlméreteket kicsiben akarjuk tartani, hozzunk létre egy helyi URLS.PY -t a Feed alkalmazásunkban, amely így néz ki:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.feed, name='feed'),
]

Azt is szerkesztenünk kell az URLS.PY -t az alap alkalmazásban, bármit is döntöttünk úgy, hogy hívjuk, ez volt az első könyvtár. Szerkessze az app/app.py -t, és adja hozzá a következőket az URL -mintákhoz

from django.urls import include # tetején
    # ... az előző kód itt

Most, amikor a kiszolgálót a Python kezeléssel.py runserverrel futtatjuk, akkor látjuk az általunk létrehozott oldalt, mert megvan a modell, a nézet és a sablon, valamint az URL -minta, valamint az adatbázis elemei. Ezután hajtsuk végre a létrehozott űrlapot, és kezdjük el létrehozni a saját hozzászólásainkat. De mielőtt túl sok kódot írnánk, készítsünk biztonsági másolatot a korábban írt szkript segítségével, a Biztonsági másolat. Futtassa ezt a szkriptet a Shell -ben, várjon néhány pillanatra, és az összes kód biztonsági másolatot készít a GIT -tárolónkba.

backup

Az űrlap megvalósítása viszonylag egyszerű. Importáljuk az űrlapunkat, hozzáadunk egy postakérési kezelőt a nézethez, és elmentjük az adatbázisba történő bejegyzést, mielőtt ugyanazon nézetre irányítanánk. Használhatjuk a már importált átirányítási funkciót, és egy másik, a Reverse nevű funkciót, hogy megkapjuk az URL -t a nézetmintához. Ezt lekérdezzük a „Feed: Feed" karakterlánccal, mert a mellékelt minta névtere takarmány, és a nézetet takarmánynak is nevezzük.

    posts = Post.objects.all() # Kérdezze meg az eddigi adatbázis összes hozzászólását
    if request.method == 'POST': # Kezelje a postakérést
        form = PostForm(request.POST) # Hozzon létre egy űrlap példányát, és mentse el az adatokat
        if form.is_valid(): # Érvényesítse az űrlapot
            form.save() # Mentse el az új objektumot
        return redirect(reverse('feed:feed')) # Átirányítsa ugyanazon URL -re egy GET kéréssel
        'form': PostForm(), # Ügyeljen arra, hogy továbbadja az űrlapot a kontextusba, hogy meg tudjuk adni.

Most frissítenünk kell a sablont az új űrlap figyelembevétele érdekében. Ezt megtehetjük a

Bontjuk le ezt. Van egy új formaosztály, egy token, maga az űrlap és a Beküldés gomb. Nagyon egyszerű, de amikor megnézzük, érdemes lehetne jobban kinézni. Működik, új hozzászólásokat tehetünk közzé az űrlapmal, és ezeket most az adatbázisba menti. Néhány dolog folyik itt. A HTML címkékkel kijelentjük, hogy a dokumentum HTML dokumentum, egy sabloncímkét ({ %… %}) használunk az űrlap tokenének megjelenítéséhez, és egy másik, {{…}} az űrlap megjelenítéséhez. Van egy hurok is, hogy blokkcímkékkel és sabloncímkével hozzuk létre a szöveget. A blokkcímkék nagyon fontosak, mert meghatározhatjuk, hogy a sablon szakaszai hogyan jelennek meg velük, és a sabloncímkék képezik annak alapját, hogy a változókat hogyan helyezzük a kódunkba.

Most azt kell tennünk, hogy az alkalmazásunk jobban nézzen ki, mert egyelőre nagyon alapvetőnek tűnik. Ezt megtehetjük CSS használatával, akár inline, akár a dokumentum minden objektumához kötött osztályokban. A CSS nagyon szép, mert mindent elmond az oldalon, hogyan kell kinéznie, és nagyon jól néz ki. Van néhány könyvtár, amely ezt megteheti, de a személyes járatom a bootstrap.

A bootstrap letölthető a weboldalukról,getbootstrap.com/- Ha egyszer ott van, nyomja meg a gombot a telepítési dokumentumok elolvasásához, és másolja a kódot a CDN szakaszon keresztül. Szüksége lesz erre a kódra a HTML dokumentum tetején, a HEAD nevű címkében. Menjünk tovább, és hozzunk létre egy alapsablont, így nem kell ezeket a linkeket újjáélesztenünk minden sablonban.

Készítsen egy új, sablonnak nevezett könyvtárat MkDIR sablonokkal, majd szerkessze a sablonokat/base.html.

Úgy kell kinéznie:

Ügyeljen arra, hogy másolja a CSS -t és a JavaScriptet, a .css és .js fájlokat, mert szükségünk lesz a JavaScriptre, hogy webhelyünket a jövőben funkcionálisabbá tegyük.

Most térjünk vissza a bash héjba, és futtassunk egy gyors parancsot. Ne feledje, hogy ha valaha is hozzáférnie kell a virtuális környezethez, írja be a Source venv/bin/aktiválást. Ez lehetővé teszi, hogy a Python csomagokat helyben telepítse oly módon, hogy a Django hozzáférhessen hozzájuk. Annak érdekében, hogy a Django Bootstrap osztályok által generált űrlapjainkat megkapjuk, a Crispy Forms nevű Python csomagot fogjuk használni. Ezt a következő paranccsal tölthetjük le

pip install django-crispy-forms

A telepítés után adja hozzá a suttings.py -hez

    # … Előző kód itt

Most, vissza a takarmánysablonunkba, eltávolíthatunk néhány dolgot. Távolítsuk el a dokumentum elejét és végét, és cseréljük le örökséggel az alapsablonunkból, a kiterjesztésekkel és a blokk meghatározásával. Ezenkívül hozzáadunk egy sablonszűrő importálását terheléssel és egy sablonszűrővel az űrlaphoz. Végül, adjunk hozzá egy bootstrap osztályt az űrlap gombjához, hogy ez inkább egy gombnak tűnjön. Ennek így kell kinéznie:

Gyönyörű! Ez már elég kis kód. Ezután ki kell tesztelnünk, és ellenőriznünk kell, hogy láthatjuk, hogy minden szépen néz ki, és biztos, hogy minden megfelelően működik. Futtassa a szervert az előző utasítások szerint, és ellenőrizze, hogy a webhely rendben van -e és működik -e. Nagyszerű munka! Készen állsz a következő lépéshez, amelyben hasonló URL -ek, űrlapok, nézetek és sablonok felhasználásával hozzáadjuk a felhasználói bejelentkezési funkciókat. Az alapsablon fontos, és továbbra is módosítjuk azt, és szükség szerint változtatunk, de egyelőre összpontosítsunk webhelyünk biztonságosabbá tételére, azáltal, hogy lehetővé teszjük a felhasználók számára, hogy felhasználónévvel és jelszóval jelentkezzenek be, és végül még fontosabb információkkal, amelyek segítenek az alkalmazás biztonságának és a saját fiókjának csak az Ön számára elérhetővé tételéhez.

Ehhez a Djangóba beépített felhasználói modellt kell használni. A felhasználói modell egy olyan adatbázis -modell, mint a bejegyzésünk, amelyet a felhasználó bejelentkezésére lehet tenni a weboldalra. A jövőben, mielőtt a webhelyet az internetbe telepítenénk, ezt a modellt másnak tulajdonított más modellekkel bővítjük, és további biztonsági intézkedéseket hozunk a bejelentkezéshez, amelyek ellenállnak az adathalásznak. Először néhány beépített bejelentkezési űrlap használatával kezdjük, amelyet a Django nyújt. Először hozzunk létre egy új alkalmazást, amelyet az alapvető bejelentkezési oldal sablonjainak és nézeteinek megjelenítéséhez használunk. Más alkalmazásokat is létrehozunk a folyamatos bejelentkezési kihívások ábrázolására az alkalmazás biztosítása érdekében, beleértve a PINCODE -t, az arcfelismerést, a közeli terepi kommunikációt, a külső eszközöket, a több tényező hitelesítését és az ujjlenyomat -felismerést.

Már beszéltünk egy alkalmazás indításáról. Könyvtárunkból, a virtuális környezetben, adja át a kezelés.py ezeket az érveket

python manage.py startapp users

Most rendelkeznünk kell egy könyvtárra az új alkalmazáshoz. Kezdjük azzal, hogy létrehozunk egy nézetet abban a könyvtárban, amely megfelel a felhasználói bejelentkezésnek. A Django a felhasználói bejelentkezési nézeteket építette be, de ezek nem lesznek megfelelőek számunkra, mert szükségünk van egy egyedi nézetre, amelyet lehetőleg egy meghatározással végeznek.

Ebben a nézetben elkezdjük egy postai kérés ellenőrzésével, a kérés átadásával.

A felhasználók/nézetekben add hozzá a következő kódot

        username = request.POST['username'] # Szerezze be a felhasználónevet és a jelszót a postai kérésből
        password = request.POST['password'] # Hitelesítse meg a felhasználót

Ez minden, amire szüksége van egy alapvető bejelentkezési nézethez. Hozzon létre egy űrlapot a nézethez az alapsablon kiterjesztésével. Először egy új könyvtár létrehozásával kezdjük a felhasználói mappában található sablonokhoz.

mkdir users/templates
mkdir users/templates/users

Most már képesnek kell lennünk a felhasználók/sablonok/felhasználók/login.html szerkesztésére. Amíg rajta vagyunk, létrehozunk egy sablont, amely lehetővé teszi a felhasználó számára is, hogy regisztráljon.

nano users/templates/users/login.html

Most, a sablonban,

Ez a bejelentkezési sablon alapjai. Valójában csak olyan, mint a többi sablon szerkezetében, de kissé másképp néz ki, amikor megjelenik. Másolhatjuk ezt a kódot egy másik nagyon hasonló sablon felépítéséhez, a Register.html néven, ahol megváltoztatjuk a megfogalmazást, és használunk egy új formát, amelyet felépítünk. Készítsük először a sablont. Szerkessze a felhasználók/sablonok/felhasználók/regisztráció.html, és adja hozzá a következő kódot:

Most készítsünk egy űrlapot a felhasználói regisztrációhoz, és térjünk vissza a nézetekhez, mielőtt a felhasználói bejelentkezésünket modellel frissítenénk. Ezt az űrlapot alapvetővé tesszük, de beépítjük a további részleteket és biztonsági funkciókat, például a megállapodások és a CAPTCHA a jövőben. Szerkessze az űrlapokat a Nano felhasználók/formájú.py segítségével, és adja hozzá a következő kódot.

from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm

class UserRegisterForm(UserCreationForm):
    email = forms.EmailField()

    class Meta:
        model = User
        fields = ['username', 'email', 'password1', 'password2']

Tehát van itt egy másik forma, amely meglehetősen egyszerűen működik. Ez egy felhasználónév, e -mail és jelszóval, valamint a Jelszó megerősítésével. Vegye figyelembe, hogy ez az űrlap nem terjeszti ki a szokásos űrlapokat. Form osztály, ez egy modell forma, amely azt jelenti, hogy van egy meta. Az egyik mező ugyanúgy van meghatározva, és az osztály meta meghatározza a modellt. Az űrlap megfelel az űrlapra írott információk többi részének. Ennek nagy része már létezik a Django beépített felhasználói számára, tehát ezt fogjuk használni az osztály alapjául (a zárójelben átadott).

Ezután megvizsgáljuk a felhasználó regisztrációjának nézetet, most, hogy van egy űrlapunk és sablonunk. Ez egy Modelform, csakúgy, mint az új Post nézetben. Szerkessze a felhasználókat/nézeteket.py -t, és adja hozzá a következő kódot:

# … Importál

Ez minden, amire szükségünk van a felhasználó regisztrálására, de további információkkal kell rendelkeznünk. Szeretnénk tudni, hogy a felhasználó regisztrált ideje, mikor volt utoljára a webhelyen, néhány információt róluk, például egy életrajz, időzóna stb. Ennek érdekében mindkét alkalmazásban frissítjük a modelleket. Kezdjük a takarmánymodell szerkesztésével. Most így kell kinéznie:

from django.db import models # … Importál
    author = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True, related_name='posts') # Adja hozzá ezt a sort

Vigyázzon a fájlba hozzáadott második sorra. Ez egy idegen kulcs, amely minden bejegyzést hozzászólásonként egyetlen felhasználónak tulajdonít, így megbizonyosodhatunk arról, hogy a hozzászólásokat felhasználó-felhasználó-felhasználó alapon mentjük, és nem lehet hozzászólni anélkül, hogy a felhasználónak tulajdonítanánk. Ezt az idegen kulcsot az általa képviselt osztály segítségével definiáljuk, egy törlés argumentumot annak biztosítása érdekében, hogy a hozzászólásokat töröljék a felhasználókkal, a NULL és az üres argumentumokkal, hogy megbizonyosodjunk arról, hogy szükség esetén eltávolíthatjuk a felhasználót, és hogy megfeleljünk a felhasználó hiányának a már létrehozott hozzászólásokon, és egy kapcsolódó névvel, amelyet felhasználhatunk a felhasználó által létrehozott objektumok hivatkozásához. Ez a kapcsolódó név, ellentétben a Post.authorral, a bejegyzés szerzőjével, olyan felhasználót ad nekünk, aki maga küldte el a bejegyzést. Most beszerezhetjük a felhasználót, amelyet a felhasználó a user.posts.ll () vagy az Authater.posts.lh () futtatása alatt készítünk.

Most tegyük fel a bejelentkezési képességeinket. A webhelyünket már sokkal kevésbé érzékenyíthetjük az adathalászatra azáltal, hogy egyszerűen korlátozzuk, hányszor engedélyezzük a webhely bejelentkezését, ez meglehetősen egyszerű. Kezdjük el az összes felhasználóról szóló információk tárolását is, miközben folytatjuk az alkalmazásunk fejlesztését. A felhasználók/modellek szerkesztése.py, adja hozzá a következő kódot.

from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone

class Profile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, null=True, blank=True, related_name='profile')
    account_created = models.DateTimeField(default=timezone.now)
    last_seen = models.DateTimeField(default=timezone.now)
    can_login = models.DateTimeField(default=timezone.now)
    preferred_name = models.CharField(max_length=20,default='', null=True, blank=True)
    bio = models.TextField(blank=True, default='')

Vegye figyelembe, hogy ez a modell meglehetősen hasonló a postmodellhez. Van egy további importálása, a TimeZone, amely lehetővé teszi számunkra, hogy az alapértelmezett értékeket a DateTime mezőkön beállítsuk, és van egy karakter és textfield, mint például a bejegyzés. Az összes időbélyeg használata segít abban, hogy biztosítsuk a webhelyet és megértsük annak használatát, és a szövegmezők adjunk információkat az egyes felhasználókról vagy szerzőkről a weboldalon. Az Onetoonefieldnek az egyetlen kisebb szempontnak kell lennie, pontosan ugyanúgy viselkedik, mint az elõzõk, de a későbbi modellnél csak egy. Ilyen módon a felhasználónak csak egy profilja van, bár lehet, hogy sok hozzászólásuk van.

Most javítsuk a bejelentkezési és regisztrálási nézetünket a profil elszámolásához. Először szerkessze a felhasználókat/nézeteket.py -t, és összpontosítson a regisztrációs nézetre:

# … Importál
            Profile.objects.create(user=user) # Feltétlenül adja hozzá ezt a sort, hogy létrehozzon egy profilt a felhasználó számára

Ez egyszerűen létrehoz egy profilt a felhasználó számára, anélkül, hogy kitöltené az információkat. Most azt szeretnénk biztosítani, hogy a felhasználói fiókot nem lehet túl gyakran bejelentkezni, vagy legalábbis a jelszavakat nem lehet túl gyakran kipróbálni, tehát frissítsük a bejelentkezési nézetet.

# … Importál
        if user and user.profile.can_login < timezone.now(): # Vegye figyelembe, hogy most ellenőrizzük, hogy a felhasználó be tud -e jelentkezni
        else: # Ha a bejelentkezés nem volt sikeres,
            user = User.objects.filter(username=username).first() # Ez az a rész, ahol frissítjük a felhasználói profilt
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # Tehát néhány másodpercig nem tudnak újra bejelentkezni

Ez a biztonság alapvető alapvető. Ügyeljen arra, hogy a webhely ne legyen kiszolgáltatott valaki, aki egyszerűen csak minden lehetséges jelszó -kombinációt próbál ki, vagy akár néhányat egyszerre. Ez nem fog csalódni a hétköznapi felhasználó számára, aki ismeri a jelképet, és csak néhány eszközön jelentkezik be, de számos adathalász robotot távol tart az alkalmazásból. Vegye figyelembe, hogy hozzáadottunk egy IF utasítást egy változóval, a CAN_LOGIN -vel, ennek a múltban időnek kell lennie, és frissítsük azt minden sikertelen bejelentkezéssel ugyanazon felhasználónév segítségével. Ilyen módon egy rosszindulatú felhasználó nem tudja kitalálni egy jelszót olyan gyorsan. A DateTime.timEdelta () másodpercek száma is frissíthető, és a weboldal rugalmasabb lesz, mégis kissé kevésbé használható, több másodperc mellett. Ajánlom a 15 -et, hogy kezdje.

Ne feledje, hogy készítettünk egy biztonsági mentési szkriptet a munkánk megmentésére, tehát menjünk előre, és készítsünk biztonsági másolatot az eddigi rendelkezésünkre, hogy megbizonyosodjunk arról, hogy mindent elmentünk. Futtassa a parancsot:

sudo backup

Ez ismét megmenti a munkáját eddig. Azt javaslom, hogy futtassa a gyakori biztonsági mentéseket a munkájának megmentése érdekében, és érdemes automatikusan futtatni a biztonsági mentési feladatot. Ezt megteheti a Cron nevű UNIX segédprogram segítségével. A segédprogram aktiválásához futtassa a következő parancsot, és írja be a jelszavát:

sudo crontab -e

Ha még nem választotta ki a Nano 1. lehetőségét, akkor a szövegszerkesztőnek, amelyet már ismerni kell, és görgessen a fájl aljára a nyílgombok segítségével. Adja hozzá a következő sort:

0 * * * * sudo backup

A Cron a formátumot, az órát, a hónapot, a hónapot, a hét napját használja, ahol A * vagy egy szám jelzi, mikor kell futtatni a parancsot. Ha a perc elején minden órás első percben futtathatunk egy parancsot a percre, és * a többi lehetőséget, a perc elején futtathatunk egy parancsot. Ez lehetővé teszi, hogy automatikusan biztonsági másolatot készítsen a kódról. A Cron összes feladata, ha a Sudo -val gyökérként hajtják végre, tehát nem kell óránként beírnunk jelszót.

Annak érdekében, hogy megkönnyítsük a kódunk biztonsági másolatának jelszava nélkül, tiltsuk le a biztonsági mentési parancs jelszavát. Ezt a következő parancs végrehajtásával és jelszó megadásával fogjuk megtenni:

sudo visudo

Most görgessünk a fájl aljára, és adjunk hozzá egy újabb sort:

ALL ALL=NOPASSWD: /bin/backup

Ez lehetővé teszi, hogy a "Biztonsági másolat" parancsot bármely felhasználóként futtassuk, jelszó nélkül. Ennek formátuma egyszerű, csak előtagolja a sort az "all = nopasswd:/bin/" című sorral, és véget érjen a paranccsal, például/bin/biztonsági mentéssel, amely a/usr/bin/ -ben létezik.

Most kezdjük el az e -mailben dolgozni. Az e -mail nagyon fontos a weboldalak számára, mert ez egy módja annak, hogy a weboldal biztonságosabb legyen, ellenőrizze, hogy a felhasználók valódi emberek -e, sőt még a termékeket vagy szolgáltatásokat az ügyfelek számára. Sokan, akik gyakran gyakorolják az internetet, naponta ellenőrzik az e -mailjét, és mindenféle marketing -e -mailt kapnak az érdeklődő termékekről és szolgáltatásokról. Van néhány lehetőség, amikor az e -maileket engedélyezi egy Django weboldalon, és szívesen választja meg, hogy melyik a legjobban.

Először fizethet egy e -mail szolgáltatásért, amely lehetővé teszi e -mail küldését a domainjéről, és minimális kódot igényel. Számos szolgáltatás kínálja ezt, például a Google Workspace, a SendinBlue, a Mailgun és még sok más.

Ellenkező esetben a saját e -mail szolgáltatásának a kiszolgálón a semmiből való felépítése. Javaslom ezt a lehetőséget, annak ellenére, hogy több kód, és speciális tárolást igényelhet. Valószínűleg nem fog elindítani egy e -mail szerver otthoni számítógépéről, tehát menjünk tovább, és vizsgáljuk meg a konfigurációt és a kódot, hogy e -mailt küldjön, mielőtt egy szerver elindulna a felhőben, és létrehozzuk a saját e -mail szerverünket.

Először szerkessze a suttings.py -t a következő paranccsal:

nano app/settings.py

Ahol az alkalmazás a StartApp segítségével létrehozott alkalmazás neve.

Adja hozzá a következő sorokat:

SITE_NAME = 'Django App'

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'localhost'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_ADDRESS = username@server.com'
EMAIL_HOST_USER = 'username'
EMAIL_HOST_PASSWORD = config['EMAIL_HOST_PASSWORD']
DEFAULT_FROM_EMAIL = '{} <{}>'.format(SITE_NAME, EMAIL_HOST_USER)

Feltétlenül változtassa meg ezeket, amikor készen áll az alkalmazás telepítésére, ezt később újra megvizsgáljuk. Az e -mail_address beállításnak az e -mailnek kell lennie, amelyet el szeretne küldeni, és a jelszót (e -mail_host_password) a szerverhez generált jelszóra kell állítani. Betöltöm a jelszót egy konfigurációs fájlból, hogy a következő logika segítségével elkerülje a kódot, a settings.py e sorok felett:

import os
import json
with open('/etc/config.json') as config_file:
    config = json.load(config_file)

Ezután beállítottam egy JSON -fájlt az infigurációval az /etc/config.json alkalmazásban, a Nano használatával az alábbiak szerint.

A fájl szerkesztése:

sudo nano /etc/config.json

Adja hozzá a következő sorokat:

{
	"EMAIL_HOST_PASSWORD": "<some password here>"
}

Folytatjuk a konfigurációs fájl szerkesztését, és hozzáadjuk az összes jelszót és kulcsot, amelyet az alkalmazásban használunk. Egyelőre gyorsan vizsgáljuk meg, hogyan lehet e -mailt küldeni a Python használatával. Először hozzon létre egy sablont egy olyan ellenőrző e -mailhez, amelyet elküldhetünk a felhasználóknak, és tegyük be a felhasználói sablonok könyvtárába. Ezt a sablont HTML -ben írják.

nano users/templates/users/verification_email.html

Ez az e -mail meglehetősen egyszerű. Ez egy felhasználó, a webhely alap URL -jének, valamint a felhasználó e -mailjének ellenőrzésére használható felhasználó, valamint a felhasználói azonosító és a token kontextusában veszi figyelembe. Ügyeljen arra, hogy meghatározza az alap URL -t a suttings.py webhelyen, mielőtt írnánk néhány Python -kódot a sablon megjelenítéséhez. Menj előre, és adja hozzá a következő sorokat az app/suttings.py -hez, a kezdet közelében.

SITE_NAME = 'Django App'
PROTOCOL = 'https'
DOMAIN = 'example.com'

BASE_URL = PROTOCOL + '://' + DOMAIN

Végül, amikor webhelye készen áll az internetre, és telepíti azt, akkor a domain -t úgy kell meghatároznia, mint a webhely ábrázolásához vásárolt domain név. Ez a név, amelyet beír a navigóriumba, hogy elérje a webhelyét. Egyelőre hagyhatja a domaint üresen, vagy használhat helyőrzőt. Azt is szeretné megváltoztatni, hogy a site_name néven olyan névre kerüljön, amelyet a választott webhelyén szeretne megadni.

Mielőtt e -mailt küldenünk, hozzunk létre egy token generátort, hogy rendelkezzünk egy fiók aktivációs tokent, amely soha nem jár le. Ezt megtehetjük egy olyan számla aktiválási token felépítésével és importálásával, amely a következőképpen néz ki. A fájl szerkesztése:

nano users/tokens.py

Adja hozzá a következő kódot:

from django.contrib.auth.tokens import PasswordResetTokenGenerator
import six
class TokenGenerator(PasswordResetTokenGenerator):
    def _make_hash_value(self, user, timestamp):
        return (
            six.text_type(user.pk) + six.text_type(timestamp)
        )
account_activation_token = TokenGenerator()
unsubscribe_token = TokenGenerator()

Ez az alapvető token generátor tokent generál, amelyet a felhasználó URL -be küldhetünk, és a felhasználó felhasználhatja e -mailjük ellenőrzésére és a fiókjuk aktiválására.

Ezután nézzük meg, hogyan küldhetünk e -mailt. Nano használatával, a felhasználók/e -mail.py szerkesztése.

nano users/email.py

A HTML e -mail ellenőrzésének küldése így fog kinézni:

from django.contrib.auth import get_user_model
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.contrib.sites.shortcuts import get_current_site
from django.core.mail import send_mail
from django.template.loader import render_to_string
from django.utils.encoding import force_bytes
from django.core.mail import EmailMultiAlternatives
from django.shortcuts import render
from .tokens import account_activation_token
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from django.template import Template, Context
from django.conf import settings
import traceback

def send_verification_email(user):
    User = get_user_model()
    mail_subject = '[{}] Activate your account.'.format(settings.SITE_NAME)
    html_message = render_to_string('users/verification_email.html', {
        'user': user,
        'domain': settings.DOMAIN,
        'protocol': 'https',
        'uid': urlsafe_base64_encode(force_bytes(user.pk)),
        'token': account_activation_token.make_token(user),
    })
    send_html_email(user, mail_subject, html_message)

Ez meglehetősen egyszerű. Importáljuk azokat a funkciókat, amelyeknek el kell küldeni az e -mailt, az e -mailt sablonokkal és beállításainkkal, majd az e -mailt a sablonnév szerint definiáljuk, és egy függvény segítségével elküldjük a felhasználó számára. Észre fogja venni, hogy még nem határoztuk meg a küldemény küldésének funkcióját, a send_html_email -t, szóval írjuk be az alábbi kódot, amelyet már hozzáadtunk a felhasználókhoz/e -mailhez.py -hez

def send_html_email(user, mail_subject, html_message):
    to_email = user.email
    username = user.username
    if to_email == '':
        return None
    unsub_link = settings.BASE_URL + user.profile.create_unsubscribe_link()
    html_message = html_message + "<p><a href=\"" + unsub_link +  "\" + title=\"Unsubscribe from " + settings.SITE_NAME + " emails\">Unsubscribe</a></p></body></html>"
    msg = EmailMultiAlternatives(mail_subject, strip_tags(html_message), settings.DEFAULT_FROM_EMAIL, [to_email], headers={'List-Unsubscribe' : '<' + unsub_link + '>'},)
    msg.attach_alternative(html_message, "text/html")
    profile = user.profile
    try:
        msg.send(fail_silently=False)
        if not profile.email_valid:
            profile.email_valid=True
            profile.save()
    except:
        profile.email_valid=False
        profile.save()

Ez egy kicsit összetettebb, és még nem állunk készen arra, hogy ezt a kódot futtassuk. Figyelem, hogy meghatározunk egy Unsub_Link -et, a felhasználó linkjét felhasználhatja az e -mailek leiratkozásához. Ez fontos, mivel a felhasználóknak képesnek kell lenniük arra, hogy kilépjenek az e -mailjeinkről, hacsak nem akarják őket látni. Hozzáadunk egy szöveges alternatívát is az üzenetünkhöz, amely a HTML -üzenetek HTML -címkékből. Végül ellenőrizzük, hogy az e -mail elküldte -e, és ha nem, akkor a felhasználó profiljában megjelöljük, hogy az e -mail nem érvényes.

Visszatérjünk vissza a felhasználói modellekbe, hogy mindez működhessünk. Meg kell határoznunk egy funkciót, hogy linket hozzunk létre a leiratkozáshoz, és meghatározzuk a logikai mezőt, hogy megjelöljük, hogy a felhasználó e -mailje nem érvényes.

Először adja hozzá a következő importokat a felhasználók/modellek tetejéhez.py

nano users/models.py

# …

Ezután adjunk hozzá funkciókat a felhasználói modellhez, hogy elkészítsük a token -t, és ellenőrizzük az e -mail aktiválásához használt tokent, valamint a mezőt, hogy megtakarítsuk, hogy a felhasználó sikeresen megkapja -e az e -mailjét. Ismét a felhasználók/modellek.py oldalon adjuk hozzá a következő kódot a modell végéhez (behúzott kód)

# …
            TimestampSigner().unsign(key, max_age=60 * 60 * 24 * 30) # 30 napig érvényes

Ez meglehetősen egyszerű, egy időbélyegzőt használunk, amely egy alapvető kriptográfiai eszköz, egy token létrehozásához, amely egy bizonyos idő elteltével lejár, és egy másik funkciót is használunk annak ellenőrzésére, hogy érvényes -e. Ezeket a tokeneket kétszer, egyszer használjuk az e -mail ellenőrzéséhez, és egyszer egy leiratkozási linkhez.

Most, hogy megvannak ezek, az utolsó munka, amelyet meg kell tennünk, a nézetekben van. A Felhasználók/Views.py webhelyen adjunk hozzá nézeteket az e -mail cím ellenőrzéséhez és a leiratkozáshoz.

nano users/views.py

Először adja hozzá a következő behozatalt. Néhány extra dobtam, így később nem kell több elemet importálnunk.

from .email import send_verification_email # Ügyeljen arra, hogy importálja az ellenőrző e -mail küldési funkciót

Lehet, hogy már van néhány ilyen behozatal, de nem árt, ha megismétli őket. A hitelesítési e -mail küldés funkciót, valamint a user_activation_token -t kell importálnia a felhasználóktól.

Most, a fájl alján adja hozzá a következő kódot:

        # leiratkozni őket
    # Egyébként átirányítja a bejelentkezési oldalt
# sendwelcomeMail (kérés, felhasználó)

Ez sok kód. Bontjuk le. Az első, tiszta és egyszerű funkció leírja a felhasználót a levelezőlistából. A második funkció aktiválja az e -mailt, és észreveszi, hogy hozzáadtam egy kommentált funkciót, a sendwelcomeMail -t. Üdvözöljük egy e -mail sablonot és a funkciódefiníciót, hogy üdvözlő e -mailt küldjön, még nem. Az utolsó funkció, amelyet dobtam, fontos, mert az aktiválási e -mailek lejárnak. Ezért időnként el kell küldenünk az aktiválási e -mailt. Használhatunk egy alapvető űrlapot erre, és felhívhatjuk a funkciót az ellenőrző e -mail elküldésére. Mielőtt ezt megtennénk, győződjünk meg arról, hogy elsősorban elküldik -e azáltal, hogy hozzáadjuk egy függvényhívást a regisztrációs nézethez. Adja hozzá ezt a sort közvetlenül az átirányítás előtt a Register View, DEF regisztrációban, a felhasználók/nézetben.

nano users/views.py

# … (Után) def regisztráció (kérés):
# … (Korábban) átirányítás (

Nem kell hozzáadnia az első és az utolsó sorokat a kódrészletbe, csak győződjön meg arról, hogy a regisztrációs nézet elküldi az ellenőrző e -mailt a felhasználónak. Úgy kell kinéznie:

# … Importál
            send_verification_email(user) # Ügyeljen arra, hogy hozzáadja ezt a sort!

Most hozzá kell adnunk egy űrlapot az aktiválási e -mail elhelyezéséhez. A felhasználók/űrlapok.py alkalmazásban adja hozzá a következő űrlapot:

# … (Import)

Szükségünk lesz egy sablonra is, amely megfelel ennek az e -mail aktiválási űrlapnak. Adjuk hozzá ezt a sablont. Szerkesszük a fájlt:

nano users/templates/users/resend_activation.html

Ezután adja hozzá a következő kódot a fájlhoz.

Whew, ez nagyon sok! Most, amikor a kódot kiszolgálónkba telepítjük, képesek leszünk HTML e -mailt küldeni, és a felhasználói fiókokat egy kattintással aktiválhatjuk az e -mailben. Lehet, hogy el kell küldeni egy egyszerű üdvözlő e -mailt is, szóval nézzük meg, hogyan kell ezt megtenni. Vissza a felhasználók/e -mail.py webhelyen, add hozzá a következő kódot:

def sendwelcomeemail(user):
    User = get_user_model()
    html = open('{}/users/welcome_email.html'.format(settings.BASE_DIR)).read()
    subject = 'Welcome to ' + settings.SITE_NAME + ', {{ username }}!'
    template = Template(html)
    subjtemplate = Template(subject)
    context = Context({'username': user.username, 'base_url': settings.BASE_URL, 'model_name': 'Daisy Holton, 'site_name': settings.SITE_NAME})
    renderedtemplate = template.render(context)
    subjcontext = Context({'username': user.username})
    subjrenderedtemplate = subjtemplate.render(subjcontext)
    send_html_email(user, subjrenderedtemplate, renderedtemplate)

Szükségünk lesz egy sablonra is, amely az összes információt megadja. A weboldalamon a sablon az alábbiakhoz hasonlóan néz ki, de szívesen formázza, amennyire csak tetszik.

Vegye figyelembe, hogy nincs bezáró test vagy HTML címkék, mert ezeket hozzáadjuk, amikor hozzáadjuk a HTML leiratkozási linket. Ezek fontosak, de nem akarjuk kétszer meghatározni őket.

Szóval mi lesz a következő? Hosszú utat tettünk meg. Valójában készen kell állnunk arra, hogy a webhelyet egy szerverre telepítse. Hozzáadhatjuk a @login_required dekorátort, és biztonságossá tehetjük a véleményünket, felvegyük a felhasználói regisztrációkat, küldhetjük el a megfelelő e -mailt és a gyorsítótár -információkat, ami az alapja annak, amit egy weboldalnak kell tennie, hogy releváns maradjon. Hozzáadunk néhány további hasznos funkciót, majd alapot készítünk a kódunk távoli kiszolgálóra történő telepítéséhez, a Mail Server, a Domain konfiguráció és a szűrők beállításához, hogy webhelyünk biztonságos és megfelelő legyen.

Szükségünk lesz egy jelszó -visszaállítási nézetre is, ezért adjuk hozzá ezt nagyon gyorsan. A Django beépített jelszó -visszaállítási nézete bizonyos funkciókban megszakad, de megvizsgáljuk, hogyan kell megírni a saját nézetünket, az e -mail sablonunkat, az űrlapokat és az URL -mintákat. Így néz ki a nézet a felhasználókban/nézetekben.py

# ... importál

Ez az űrlap beépült a django -ba, de szükségünk van egy sablonra a jelszó visszaállításának, a felhasználóknak a/sablonok/felhasználói/password_reset_confirm.html megerősítéséhez.

Van egy sablonunk is, amelyben egy egyszerű űrlapot, a felhasználók/sablonok/felhasználók/password_reset.html fájlt küldhetünk.

Maga az e -mail sablonja egyszerű, ez egy alapvető HTML fájl, amely egy linket jelenít meg a jelszó visszaállításához, a felhasználók/sablonok/felhasználók/password_reset_email.html webhelyen. A Django automatikusan értelmezi ezt a fájlt.

Szükségünk van még két sablonra is. Az első annak megerősítése, hogy az e -mailt elküldték. Ezekre vonatkozó nézetek már Djangóban vannak, tehát csak az URLS.Py. Ez a sablon a Felhasználók/sablonok/felhasználók/jelszó_reset_done.html oldalon található

És végül, annak megerősítéséhez, hogy a jelszó -visszaállítás teljes -e, a felhasználók/sablonok/felhasználók/jelszó_reset_complete.html

Most szükségünk van URL -mintákra ezekhez a nézetekhez. A felhasználók/urls.py fájlban adja hozzá a következő URL -mintákat:

    # ... az előző URL -ek itt

Négy sablon, ez nagyon! De most biztosak lehetünk abban, hogy bármikor visszaállíthatjuk a felhasználó jelszavát, mindezt a webböngészőből.

Megértem, hogy ez sok kód. Ha kissé úgy tűnik, hogy a feje fölött, akkor ez rendben van. Javítani fog, megértése javulni fog, és hamarosan sokkal kompetensebbé válik a kóddal. Ha teljesen elveszett, azt javaslom, hogy később térjen vissza ehhez a szoftverhez, miután egy önálló tempójú megtanulta az online kódot. Ezek általában szabadon indíthatók, és mindent átvezethetnek, amire szükség van, hogy sikeres legyen, amikor visszatérsz ehhez a projekthez. Ha úgy érzi, hogy készen áll a folytatásra, olvassa el, a következő, fedezzük a kód telepítését egy távoli szerverre, és beállítunk egy Mail Server -et, valamint automatizáljuk a telepítést a BASH segítségével, így mindig beállíthat egy új projektet néhány egyszerű paranccsal.

Az utolsó dolog, amit a távoli szerverre történő telepítés előtt meg kell tennünk, az, hogy webhelyünket egy kicsit biztonságosabbá tegyük. Észre fogja venni, hogy a bejelentkezési nézet csak felhasználónevet és jelszót vesz igénybe, és nincs több tényező hitelesítés vagy egyszeri kód. Ez egy egyszerű javítás, és ugyanazzal a kóddal arra késztethetjük webhelyünket, hogy szöveges üzeneteket küldjünk, és még a kiszolgálóra küldött szöveges üzenetekre is reagálhatunk. A kezdéshez visszamegyünk a felhasználói modellekbe, és hozzáadunk egy időbélyegző aláírót, amely az egyes bejelentkezéseket képviseli. Ezenkívül hozzáadunk egy egyedi, forgó azonosítóval a felhasználói modellhez, amelyet a bejelentkezés további biztonságának hozzáadására használnak. A felhasználói modellek szerkesztése, a felhasználók/modellek.py, add hozzá a következő kódot:

# Ügyeljen arra, hogy importálja az UUID, az időbélyegző aláíró és az URL -generátort (fordított)
    # Adja hozzá ezt a kódot ide
    # És add hozzá ezt a funkciót
            TimestampSigner().unsign(key, max_age=60 * settings.AUTH_VALID_MINUTES) # 3 percig érvényes

Győződjön meg arról, hogy a felhasználók/modellek így néznek ki, a megjegyzések mellett (kód a soron a #-nel). Ezt lebontva, ez egyszerű. Van néhány behozatalunk, egy időbélyegző, amely egy kriptográfiai segédprogram, amely biztonságos kódot generálhat, és ellenőrizheti azt, hogy megbizonyosodjon arról, hogy érvényes -e, csak egyszer használják, és nem régebbi, mint egy bizonyos másodperc. Az UUID -t is használjuk, amely egyedülálló azonosító, amely azonosítja a felhasználót a token aláírásakor, és az URL -ben, ahol a tokent elküldik a felhasználónak. Ezt az alapvető kriptográfiát használjuk egy két tényező hitelesítési nézet felépítéséhez. Mielőtt bármi mást csinálnánk, futtassuk az áttelepítést, hogy a felhasználói modellek frissüljenek. A kezelés.py könyvtárban futtassa a következő parancsokat a migrációk elvégzéséhez és teljesítéséhez.

source venv/bin/activate
python manage.py makemigrations && python manage.py migrate

Ez azért fontos, mert minden alkalommal, amikor megváltoztatjuk a modelleket, létrehoznunk kell a táblákat, és frissítenünk kell az adatbázist az alapértelmezésekkel, mielőtt a modelleket ténylegesen használhatnánk.

Ezután improvizáljuk a bejelentkezési nézetünket, hogy átirányítsuk a másodlagos hitelesítési nézetre. A Felhasználók/Views.Py webhelyen távolítsa el a bejelentkezési funkciót, és irányítsa át az URL -re, amelyet éppen a felhasználói modellekben generáltunk.

# … Importál
        if user and user.profile.can_login < timezone.now(): # Vegye figyelembe, hogy most ellenőrizzük, hogy a felhasználó be tud -e jelentkezni
            # Távolítsa el az itt található Auth_login funkciót
                return redirect(user.profile.create_auth_url()) # Megjegyzés: Itt átirányítjuk egy új URL -re
            else: # Ha a felhasználó nem használ többtényezős hitelesítést, csak jelentkezzen be.
        else: # Ha a bejelentkezés nem volt sikeres,
            user = User.objects.filter(username=username).first() # Ez az a rész, ahol frissítjük a felhasználói profilt
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # Tehát néhány másodpercig nem tudnak újra bejelentkezni

Tehát ez elég egyszerű, most már módjuk van átirányítani a két tényező hitelesítési nézetre, amikor létrehozzuk. Van egy tartalékunk is arra az esetre, ha a felhasználó nem adott hozzá telefonszámot. Hozzáadunk egy alapvető nézetet, hogy hamarosan hozzáadhassunk egy telefonszámot, és hamarosan bejelentkezzünk egy szöveges üzenettel.

Először is szükségünk van egy egyszerű módszerre, hogy szöveges üzenetet küldjünk a kódunkból. Ehhez számos API közül választhatunk, de véleményem szerint a legegyszerűbb a Twilio. Jó árakat kínálnak a kisebb projektekhez, valamint az ömlesztett engedményeket is. Hozzon létre egy fiókot a twilio.com webhelyen, töltsön ki néhány részletet a projektjéről, vásároljon telefonszámot, és másolja az API -kulcsokat a Settings.py oldalra. Ezután adja hozzá ezt a kódot egy új fájlba, a felhasználók/sms.y.

nano users/sms.py

# Importálja az összes szükséges csomagot
# Ez a kód elküldi a szöveget a Twilio -val
# Segítő funkció, hogy olyan sok számjegyet kapjon
# Küldje el a szöveget a felhasználó ellenőrzéséhez
# Küldjön egy felhasználót bármilyen szöveget ezzel a funkcióval
# Érvényesítse a kódot ezzel a funkcióval
# Érvényesítse az időt

Feltétlenül változtassa meg a beállításokat megfelelően, és adja hozzá ezeket a sorokat a kulcsokkal:

# Ügyeljen arra, hogy ezeket másolja a Twilio irányítópultjáról
AUTH_VALID_MINUTES = 3 # A TFA oldal percek száma aktív, ha egyszerre megjelenik

Először is szükségünk lesz űrlapokra a két tényező hitelesítési nézetünkhöz. Felhasználók szerkesztése/Forms.py, adja hozzá a következő kódot.

# … Importál
# A telefonszámunk megadására szolgáló űrlap
# A hitelesítés űrlapja

Ezután hozzuk létre a nézeteket a felhasználók/nézetekben.py webhelyen

# … Importál

Mindkét nézethez sablonokra is szükségünk lesz. Először adjuk hozzá az MFA sablont.

nano users/templates/users/mfa.html

Adja hozzá ezt a HTML -kódot a sablonhoz

Ez elég önmagában magyarázó. Az űrlap kódot vagy üres kódot küld, és észreveszi a kódot, ha egy üres kódot kapunk. Akkor csak két beküldés gomb van, és így elküldhetjük a kódot bármelyik gombbal. Ezután hozzáadunk egy egyszerű űrlapot a telefonszám hozzáadásához.

nano users/templates/users/mfa_onboarding.html

Adja hozzá a következő HTML -t:

Ez az űrlap sokkal egyszerűbb, csak így adja meg a létrehozott telefonszámot, és lehetővé teszi a felhasználó számára, hogy hozzáadjon egy telefonszámot.

Ez nagyon jól néz ki! Mindaddig, amíg minden megfelelően be van állítva, képesnek kell lennünk üzenetek küldésére, és be kell jelentkeznünk a felhasználó telefonszámával, amint hozzáadjuk az URL -mintákat. Az utolsó dolog, amit beállítani kell, egy profil nézet, így megbizonyosodhatunk arról, hogy a felhasználó megváltoztathatja telefonszámát anélkül, hogy bejelentkeznénk. Végül is hozzá kell adnunk egy "Stop to Out" opciót, így a felhasználó a "Stop" szöveget is írhatja a jövőbeni szöveges üzenetekről.

Adjunk hozzá egy profil nézetet a felhasználókhoz/a nézetekhez.py. Ez a nézet frissíti a felhasználó életrajzát, e -mailjét, felhasználónevét és telefonszámát, valamint lehetővé teszi a több tényező hitelesítés engedélyezését. Először is két további űrlapra lesz szükségünk a felhasználókban/formában.py

# ... importál

Ezután létrehozhatunk egy nézetet mindkét forma használatához. Szerkessze a felhasználókat/nézeteket.py -t, és adja hozzá a nézetet.

# Adja hozzá ezeket az importokat

Szükségünk van egy sablonra ehhez a nézethez.

nano users/templates/users/profile.html

Észre fogja venni, hogy ez egy meglehetősen egyszerű forma, de van benne néhány JavaScript, amely automatikusan közzéteszi az űrlap tartalmát, amikor frissülnek. Ez hasznos, így szerkesztéseket készíthet anélkül, hogy minden alkalommal nyomja meg a benyújtást.

Ezután szükségünk van az URL -ekre, amelyek ábrázolják ezeket a nézeteket a felhasználók URL -pattanásaiban. Szerkessze a felhasználókat/urls.py -t, és adja hozzá ezt a kódot:

# … Előző kód, importál
# … URL -minták, amelyeket korábban beírtunk, adjuk hozzá a következő három sort

Itt az ideje, hogy kipróbáljuk a projektünket. De először futtassunk egy újabb biztonsági mentést.

backup

És futtassa a kiszolgálót. Mielőtt telepítenénk egy Linux szerverre, érdemes két tényező hitelesítést engedélyezni a fiókban. Ezt megtesszük a Profil URL -hez,/felhasználók/profil/, és jelöljük be a négyzetet, hogy engedélyezze a hitelesítést a telefonszámunk megadása után, majd az űrlap benyújtása után.

python manage.py runserver localhost:8000

Látogasson el a weboldalra, ha belép a böngészőjébe, ebben a példában a Google Chrome -ot használom, és beírom az URL -t https: // localhost: 8000/fiók/profil//profil/

Szükség esetén bejelentkezhet, és engedélyezheti a két tényező hitelesítését.

Ennek a projektnek a kiszolgálóra van szüksége a futáshoz, így valóban levelet küldhet. De először is szükségünk van egy módszerre a hibák megtekintéséhez. Észre fogja venni, hogy ha a kiszolgálót hibakeresési módban futtatja, a settings.debug -nak megegyezik az igaznak, akkor a szerver automatikusan megmutatja a hibákat. A hibakeresési mód használata nélkül, amely a hibakeresési mód használata nélkül, amely nem biztonságos a termelési kiszolgálón, hozzá kell adnunk egy nézetet. A legfontosabb hibák, amelyekre képesek vagyunk, a következők:

500 hiba - probléma a kódunkkal 404 hiba - egy olyan oldal, amelyet nem találtak (törött URL) 403 hiba - Az engedély tagadta a hibát

Adjunk hozzá egy új alkalmazást ezeknek a hibáknak az úgynevezett hibák kezelésére.

python manage.py startapp errors

Adja hozzá ezt a suttings.py -hez, mint korábban, a telepített_Apps beállításban, és kezdje el, hogy hivatkozásokat adjon néhány nézethez az App/URLS.PY -ben, ahol az alkalmazás a Django projekt neve.

handler404 = 'errors.views.handler404'
handler500 = 'errors.views.handler500'
handler403 = 'errors.views.handler403'

Ez minden, amire szükségünk van a hiba nézetek, sablonok és egy kis köztes szoftver mellett. Határozzuk meg ezeket úgy:

# Hozzon létre nézeteket itt.

Ezután határozzuk meg a köztes szoftvert, hogy kezelje ezeket a hibákat. Ezt úgy fogjuk megtenni, hogy először hozzáadjuk a Middleware_Classes fájlt a suttings.py fájlban, a köztes szoftverünk nevével.

    # ... Előző köztes szoftver

Ezután adjuk hozzá a köztes szoftvert.

from threading import local
import traceback
from django.utils.deprecation import MiddlewareMixin

_error = local()

class ExceptionVerboseMiddleware(MiddlewareMixin):
    def process_exception(self, request, exception):
        _error.value = traceback.format_exc()

def get_current_exception():
    try:
        return _error.value
    except AttributeError:
        return None

def set_current_exception(exception):
    try:
        _error.value = exception
    except AttributeError:
        print('Attribute error setting exception.')

Hozzáadunk egy függvényt, hogy az aktuális kivételt egy menetes helyi használatával kapjuk meg, amely segít a kódban szereplő hibák nyomon követésében. A sablonok szempontjából csak egyre van szükségünk, mert dinamikusan definiáljuk a címet a nézetben. A sablonnak csak a címet és a "nyomkövetést" kell megadnia, a hibánkat a kontextusból.

nano errors/templates/errors/error.html

Ez még a legegyszerűbb sablonunk, de így könnyű látni a projektünk hibáit. Ezután tiltsuk le a hibakeresést a beállításokban.

nano app/settings.py

Keresse meg ezt a sort, ahol igazra van állítva, és változtassa meg hamisra

DEBUG = False

Folytassa, és készítsen biztonsági másolatot az alkalmazásról. Készen állunk arra, hogy telepítsünk egy távoli Linux -kiszolgálóra, és folytassuk a funkciókat onnan.

sudo backup

Mielőtt ezt a kódot egy szerverre tesznénk, fontolóra kell venni, hogy lehetnek néhány probléma a kóddal. Az esettől függően a nekik közzétett információkat elfogadó webhelyek problémákkal fognak tenni a spam kiküldését és a spam eltávolításának nehézségeit. Ennek nem szabad azonnal megtörténnie, de ha ez megtörténik, akkor később megvizsgáljuk, hogyan lehet automatikusan mérsékelni a spamet a webhelyen, és nehezebbé tesszük a robotok számára a webhely elérését, valamint a felhasználói fiókok kikapcsolását, és ellenőrizni a felhasználó személyazonosságát az azonosítójuk vagy a biometrikus vizsgálat vizsgálatával, például egy ujjlenyomat -felismeréssel.

A vizsgált több tényező hitelesítési példát tekintve, a gyártás során a dolgok eltérőek lehetnek. Figyelje meg, hogyan korlátozzuk a bejelentkezést és a lejárt tokeneket. Ha a robotok hozzáférnek egy webhelyhez, akkor a két tényező -hitelesítés nehezebb lehet, mivel a felhasználó egyszerre is beírhatják a kódokat. Ennek leküzdése érdekében használjuk a modellt a felhasználói modellekben, kijelentve, hogyan lépünk kapcsolatba a webhelygel, amikor a multi -faktor hitelesítéssel hitelesítünk egy telefonszámmal. Ezenkívül hozzáadunk egy lehetőséget az e -mail hitelesítéséhez. Kezdje a felhasználói modellek Nano szerkesztésével.

nano users/models.py

Így kell kinéznie az általunk hozzáadott modellnek. Nincs szükségünk semmilyen módszerre, csak a változókra az azonosító, a felhasználó, az időbélyeg, a lejárati, hossz és a több tényező hitelesítés elleni kísérletek tárolásához (olyan kód, mint például az 123456 telefonra vagy e -mailre).

# Egy alapvető token, amelyet a weboldalra való bejelentkezéshez használtak

Adjunk hozzá egy kiváltságot is a felhasználónknak, és egyelőre manuálisan állítjuk be, mielőtt végül a privilegizált felhasználók automatikus felvételére vándorolunk. A felhasználói modellekbe adja hozzá ezt a sort a profilhoz:

    vendor = models.BooleanField(default=False)

Mint az adatbázis minden változása esetén, az áttelepítést és az adatbázist át kell migrálnunk, amikor egy modell.py fájlt szerkesztünk a django -ban. Ne felejtse el, hogy ezt megtesszük, először a forrást használjuk (ha azt még nem használtuk, mivel a terminál nyitva volt), majd a Python kezelés.py -t a migráció és a migráció érdekében.

cd project-directory-you-named # (Ha szükséges)

Jelenleg a héj használatával be lehet vonni minden olyan fiókot, amelyet gyártóként hoz létre.

python manage.py shell
from users.models import Profile
p = Profile.objects.get(user__username='Charlotte')
p.vendor = True
p.save()
exit()

Most fejlesszük ki a több tényező hitelesítési nézetünket, hogy ezt a tokent használjuk. Először módosítanunk kell az MFA segítő segédprogramjainkat. Nano használatával,

nano users/mfa.py

from django.utils import timezone
import random
import datetime
from django.conf import settings
from feed.middleware import get_current_request
from django.contrib import messages
from .email import send_html_email
import traceback
from .models import MFAToken

account_sid = settings.TWILIO_ACCOUNT_SID
auth_token = settings.TWILIO_AUTH_TOKEN
source_phone = settings.PHONE_NUMBER

def send_text(target_phone, text):
    from twilio.rest import Client
    try:
        client = Client(account_sid, auth_token)
        if len(target_phone) >= 11:
            message = client.messages.create(
                to=target_phone,
                from_=source_phone,
                body=text + ' Text STOP to cancel.')
    except:
        messages.warning(get_current_request(), 'There was an error sending the message.')
        print(traceback.format_exc())

def get_num_length(num, length):
    n = ''
    for x in range(length):
        n = n + str(num)
    return int(n)

def send_verification_text(user, token):
    length = user.profile.verification_code_length
    code = random.randint(get_num_length(1, length), get_num_length(9, length));
    token.token = code
    token.expires = timezone.now() + datetime.timedelta(minutes=settings.AUTH_VALID_MINUTES)
    token.save()
    send_user_text(user, "Your verification code for {} is {}".format(settings.SITE_NAME, str(code)))

def send_verification_email(user, token):
    length = user.profile.verification_code_length
    code = random.randint(get_num_length(1, length), get_num_length(9, length));
    token.token = code
    token.expires = timezone.now() + datetime.timedelta(minutes=settings.AUTH_VALID_MINUTES)
    token.save()
    send_html_email(user, "Your verification code for {} is {}".format(settings.SITE_NAME, str(code)), "<p>Dear {},</p><p>Your verification code for {} is {}. Thank you for using this code to secure your account.</p><h2>{}</h2><p>Sincerely, {}</p>".format(user.profile.name, settings.SITE_NAME, str(code), str(code), settings.SITE_NAME))

def send_user_text(user, text):
    send_text(user.profile.phone_number, text)

def check_verification_code(user, token, code):
    token.attempts = token.attempts + 1
    profile = user.profile
    result = (token != None and code != '' and token.token == code and (token.expires > timezone.now()) and token.attempts <= settings.MFA_TOKEN_ATTEMPTS)
    if token.attempts < 3 and result:
        profile.verification_code_length = 6
    elif token.attempts > 1 and not result:
        profile.verification_code_length = profile.verification_code_length + 2
        if profile.verification_code_length > settings.MFA_TOKEN_LENGTH: profile.verification_code_length = settings.MFA_TOKEN_LENGTH
    token.save()
    profile.save()
    return result

# Hitelesítse meg a felhasználót e -mail vagy telefonszámuk segítségével
    token = MFAToken.objects.filter(uid=username, expires__gt=timezone.now() + datetime.timedelta(seconds=30)).order_by('-timestamp').last() # Szűrje ki a tokent az URL -ben átadott érték alapján (UUID)
    if not token: token = MFAToken.objects.create(user=User.objects.filter(profile__uuid=username).first(), uid=username, expires=timezone.now() + datetime.timedelta(seconds=115)) # Ha ezt a munkamenetet még nem hozták létre, akkor hozza létre
    user = User.objects.filter(id=token.user.id).first() # Szerezze be a felhasználót a tokenből
    if not user and request.user.is_authenticated: return redirect(reverse('feed:home')) # Ha már hitelesítik őket, jelentkezzen be őket
    if not user: raise PermissionDenied() # Tagadd meg, ha nem találtak felhasználót
    if not user.profile.enable_two_factor_authentication and user.is_active and user.profile.check_auth_token(usertoken, token): # Ellenőrizze az Auth Tokent
        auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Jelentkezzen be a felhasználóba, ha még nincs bejelentkezve
        user.profile.mfa_expires = timezone.now() + datetime.timedelta(minutes=settings.LOGIN_VALID_MINUTES) # Állítson le a több tényező hitelesítésének lejárta
        return HttpResponseRedirect(next if next != '' else reverse('landing:landing')) # Átirányítsa a felhasználót a következő oldalra
    if not user.profile.mfa_enabled: # Ellenőrizze, hogy az MFA engedélyezve van -e
        if not check_verification_time(user, token): # Ellenőrizze az időt
            user.profile.mfa_enabled = False # Törölje a telefonszámot
            user.profile.enable_two_factor_authentication = True # Engedélyezze az MFA -t
            user.profile.phone_number = '+1' # Tiltsa le a telefonszámot
            user.profile.save() # Mentse el a profilt
            auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Jelentkezzen be a felhasználót, ha az MFA nem engedélyezve van
    if request.method == 'POST' and not fraud_detect(request, True): # Ha a kérés egy postai kérés
        form = TfaForm(request.POST) # Instantálja az űrlapot
        code = str(form.data.get('code', None)) # Szerezd meg a kódot
        if code and code != '' and code != None: # Ügyeljen arra, hogy ne legyen üres
            token_validated = user.profile.check_auth_token(usertoken) # Ellenőrizze az Auth Tokent
            is_verified = check_verification_code(user, token, code) # Ellenőrizze a kódot
            if token_validated: # Ha minden
                if is_verified: # Rendben van
                    user.profile.mfa_enabled = True # Engedélyezze az MFA -t (ha még nem engedélyezve van)
                    auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Jelentkezzen be a felhasználóba
                    for key, value in request.GET.items(): # Készítsen egy lekérdezést a következő paraméterhez (ha van)
                        return HttpResponseRedirect(next) # Átirányít
            elif not token_validated: # Ha a token érvénytelen volt
            if p.mfa_attempts > 3: # Ha túl sok kísérlet lenne
            if form.data.get('send_email', False): # Küldje el az e -mailt (vagy szöveget)
    # Megjelenítse az űrlapot (a GET kérésekhez)

Amikor hozzáadunk ehhez a kódhoz, ügyeljen arra, hogy importálja a funkciót egy e -mail küldéséhez. A fájl tetején a felhasználói nézetek (más importálással), Add

from .mfa import send_verification_email as send_mfa_verification_email

Most meg kell írnunk ezt a funkciót, mielőtt ezek bármelyike ​​működni fog. Meg kell bővítenie a küldés e -mail funkcióját, és egyszerűen küldenie kell egy e -mailt a felhasználónak az ellenőrző kóddal.

nano users/mfa.py

def send_verification_email(user, token):
    length = user.profile.verification_code_length
    code = random.randint(get_num_length(1, length), get_num_length(9, length));
    token.token = code
    token.expires = timezone.now() + datetime.timedelta(minutes=settings.AUTH_VALID_MINUTES)
    token.save()
    send_html_email(user, "Your verification code for {} is {}".format(settings.SITE_NAME, str(code)), "<p>Dear {},</p><p>Your verification code for {} is {}. Thank you for using this code to secure your account.</p><h2>{}</h2><p>Sincerely, {}</p>".format(user.profile.name, settings.SITE_NAME, str(code), str(code), settings.SITE_NAME))

Tehát ez mind remekül működik, most már van egy multi -faktor hitelesítési rendszerünk, amely a bejelentkezési telefonszámot vagy e -mailt függ. De szükségünk van arra is, hogy eltávolítsuk, vagy legalább elrejtsük azokat a felhasználókat, akik nem működnek együtt a feltételeinkkel. Ezek lehetnek spamszelők, robotok vagy bárki, aki nem jelent jól a munkánk számára. Vessen egy pillantást egy olyan nézetre, amelyet a weboldalamon a felhasználók megfigyelésére használok:

# behozatal
from .tests import is_superuser_or_vendor # Készítenünk kell ezt a tesztet
    # Szerezd meg a felhasználók listáját
    return render(request, 'users/users.html', { # Visszaadja a felhasználókat egy sablonban

Vegye figyelembe, hogy ez a kód tesztet használ, ezt a tesztet egy teszt.py fájlban kell deklarálnunk, és importálnunk kell. A felhasználók szerkesztése/teszt.py, hozzuk létre a tesztet.

def is_superuser_or_vendor(user):
    return user.profile.vendor or user.is_superuser

Ez a felhasználókkal/felhasználókkal.

Vegye figyelembe, hogy a sablon tartalmaz egy másik sablont, a felhasználókat/user.html. Ha olyan sablonot használ, amelynek altermlapja van, és nem használja a kiterjesztéseket, jó ötlet egy aláhúzás hozzáadására () A meghosszabbításra kerülő fájl neve előtt a sablonok megkülönböztetése érdekében.

Vegye figyelembe, hogy ez sok jinja, lehet, hogy nem határozta meg ezeket a változókat. De így néz ki a kódom.

      <small># {{user.id}} </small>

Szükségünk van egy másik altermlemezre, a toggle_active.html -re is. Ennek a sablonnak olyan űrlapnak kell lennie, amely lehetővé teszi számunkra, hogy a felhasználó aktív -e.

Fel kell adnunk egy nézetet a felhasználói tevékenységek és a megfelelő URL -minták váltásához. Amíg itt vagyunk, adjunk hozzá egy nézetet a felhasználó törléséhez, ha erre szükségünk van.

# Behozatal
    success_url = '/' # A sikeres URL átirányítása
    def test_func(self): # Tesztelje, ha a felhasználó szuperuszer -e, és engedélye van a törlésre

Noha ez szükség esetén praktikus, a felhasználó törlésének a legtöbb esetben nem kell szükség, átkapcsolhatjuk azoknak a felhasználóknak a láthatóságát, akik meglátogatják a webhelyet, ha el kell utasítanunk őket.

A hozzáadott URL -minták így néznek ki. Nano segítségével szerkessze a felhasználókat/urls.py -t, és adja hozzá ezeket a sorokat:

nano users/urls.py

A vonalaknak a felhasználói nézetek útjának listájába kell menniük, a "]"] "] vége előtt, de a kezdet után" [".

# …
# …

Most ügyeljen arra, hogy biztonsági másolatot készítsen a webhelyről, így letöltheti azt a webszerveren, amelyen folytatjuk a munkát. A parancssorból,

sudo backup

Most a webhelyünk biztonsági másolatot készít.

Tehát most van még néhány hasznos funkciónk. De mi van az itt található nagy képpel? Ez a kód még mindig nem érhető el az internetről, még nincs e -mail szerverünk, és kibővítenünk kell az alkalmazásunkat, hogy átfogó ellenőrzési folyamatot és sima elrendezéseket tartalmazzunk, hogy segítsünk a webhely felfedezésében, valamint a biztonságos protokollok, a privilegizált felhasználók hitelesítésére.

Mindezt eljutunk. A legfontosabb dolog egyelőre csak az lesz, hogy ezt a kódot online szerezzék, amit csak néhány sor bash -val megtehetünk egy Ubuntu szerveren. Ennek ellenére kiszolgálót kell bérelnie, kivéve, ha otthon van egy szerver és üzleti internetes előfizetés, amely lehetővé teszi a portok megnyitását. Személy szerint a weboldalamat egy HP Z440 -en futtatom, amelyet a lakásomba telepítenek, de általában sokkal olcsóbb az alapvető igények, hogy béreljenek egy virtuális privát szervert (VPS).

Ne feledje, hogy a most futó kód viszonylag vékony, ezt meg kell karbantartani és továbbfejleszteni, mielőtt készen állunk arra, hogy felhasználjuk azt, amit egy termék felépítéséhez kell. Ügyeljen arra, hogy vigyázzon, mit csinál az internettel, győződjön meg arról, hogy ha ezt a webhelyet nyilvánosan telepíti az interneten egy Linux szerveren, akkor tervezi, hogy blokkolja a nem kívánt interakciókat a webhelyével. Ez valószínűleg eleinte nem lesz probléma, de különféle megoldásokat fogunk megvizsgálni ennek leküzdésére, beleértve a gépi tanulást, a mesterséges intelligenciát és a számítógépes látást. Amikor ez problémává válik, keresse meg tovább a szöveget a megoldáshoz.

A VPS bérlése szempontjából nagyon sok helyen lehet menni. A Google Cloud VPS -kiszolgálói, ionok, Kamatera, Amazon AWS és további szolgáltatók olyan felhőkiszolgáló megoldásokat kínálnak, amelyek megfelelnek az igényeinknek.

Kattintson az űrlapokra, és ki kell választania egy tervet az induláshoz. Bármely szolgáltatóval elindíthat egy alapvető tervvel, de győződjön meg arról, hogy a szolgáltató lehetővé teszi a portposta -kiszolgáló portjainak megnyitását az e -mail küldéséhez (ennek az 587 -es és a 25. portnak kell lennie), néhány szolgáltató blokkolja ezeket a portokat. Eddig a legjobb tapasztalatom volt az Ionos -val és a Kamatera -val, mindkettő lehetővé teszi számomra, hogy korlátlan e -mailt küldjek, és áraik elég olcsó.

Csatlakozik az új szerveréhez egy SSH vagy Secure Shell nevű protokollon keresztül, amely lehetővé teszi a személyi számítógépről való távoli interfészhez való távoli felületet pontosan, mint a személyi számítógépről. Amikor beállítja a kiszolgálót, akkor a tárhely szolgáltató valószínűleg felkéri Önt, hogy adjon hozzá egy SSH -kulcsot, különben felhasználónevet és jelszót ad neked. Az SSH kulcs az, hogy hogyan jelentkezik be a kiszolgálóra a parancssorból a kód szerkesztéséhez. Használja az alábbi SSH-KeyGen opciókat az SSH gomb előállításához.

ssh-keygen

Mentse el a fájlt, és ha szükséges, felülírja, jó az SSH -kulcsok forgatása, ha még nem tette meg. Most a következő paranccsal láthatja az SSH gombot. Meg akarja másolni a távoli szerverre, így felhasználhatja a hitelesítésre.

cat ~/.ssh/id_rsa.pub

Ha nem látta egy SSH-kulcsot, amikor beírja ezt a parancsot (egy hosszú számjegy és betű, az "SSH-RSA AAA" -val kezdődik), próbáljon meg egy RSA-kulcs generálását (ezek biztonságosabbak, ezért azt javaslom, hogy használjam őket.) A következő kód egy 4096 bites RSA SSH kulcsot generál.

ssh-keygen -t rsa -b 4096

Hozzon létre egy VPS -t, amely az Ubuntu -t futtatja, bár ezt tervezi. Miután létrehozta a VPS -t, ha rákattint a Szolgáltatók weboldalán (Kamatera.com, Ionos.com vagy hasonló) űrlapokon, be kell jelentkeznie. Ehhez használja az SSH parancsot az IP -címével (az xx.xx.xx.xx címre néző cím). Szintén érzékenynek kell lennie az alapértelmezett felhasználónévre az általunk létrehozott kiszolgálón, például az Ubuntu.

ssh ubuntu@XX.XX.XX.XX

Előfordulhat, hogy jelszót kérhet, ha jelszót kérnek, írja be. Nem fogjuk használni az alapértelmezett felhasználónevet, tehát kezdjük el egy új felhasználó létrehozásával és egy SSH -kulcs hozzáadásával a fiókjukhoz.

Kezdjük egy új SSHD_Config fájl hozzáadásával, amely megmondja a szervernek, hogyan kell használni az SSH -t.

nano sshd_config

# Ez az SSHD szerver rendszerszintű konfigurációs fájl.  Lát
# SSHD_CONFIG (5) További információkért.
# Ezt az SSHD -t a PATH =/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/játékok segítségével állították össze.
# Az alapértelmezett SSHD_CONFIG opcióihoz használt stratégiát a
# Az OpenSsh az opciók meghatározása alapértelmezett értékükkel, ahol
# Lehetséges, de hagyja, hogy kommentálják őket.  A nem komminált opciók felülbírálják a
# Alapértelmezett érték.
# 22. port
# Címkém bármilyen
# Hallgassa meg a 0.0.0.0 -t
# Hallgassa meg ::
# Hostkey/etc/ssh/ssh_host_rsa_key
# Hostkey/etc/ssh/ssh_host_ecdsa_key
# Hostkey/etc/ssh/ssh_host_ed25519_key
# Forrózók és kulcstartók
# Reekeylimit alapértelmezett nincs
# Fakitermelés
# Syslogfacility Auth
# LogLevel Info
# Hitelesítés:
# LogingRacetime 2m
# Permitrootlogin tiltott-password
# Strictmodes igen
# Maxauthtries 6
# MaxSessions 10
# Arra számíthat, hogy .ssh/engedélyezett_keys2 a jövőben alapértelmezés szerint figyelmen kívül hagyják.
# EngedélyezettPrincipalsFile Nincs
# AuthorizedKeysCommand Nincs
# AuthorizedKeyscommanduser Senki
# Ahhoz, hogy ez működjön, akkor a/etc/ssh/ssh_nown_hosts webhelyen is szüksége lesz host kulcsokra
# HostBasedAuthentication No
# Változtassa meg igenre, ha nem bízik ~/.ssh/ismert_hosts
# Gazdaszervezet
# IgnoreUsernownHosts nem
# Ne olvassa el a felhasználó ~/.rhosts és ~/.shosts fájlokat
# Tudatlanok igen
# Az alagútban lévő törlési szöveges jelszavak letiltásához változtasson itt!
# PermitEppyPasswords nem
# Változtasson igenre, hogy engedélyezze a kihívás-válasz jelszavakat (vigyázzon a kérdésekre
# Néhány PAM modul és szál)
# Kerberos opciók
# Kerberosauthentication No
# Kerberosorlocalpasswd igen
# KerberosticketCleanup igen
# Kerberosgetafstoken nem
# GSSAPI opciók
# GSSAPIAuthentication NO
# Gssapicleanupcredentials igen
# GSSAPISTRICTACCECTORCHECK Igen
# GssapikeyExchange nem
# Állítsa ezt az „Igen" -re, hogy engedélyezze a PAM -hitelesítést, a fiókfeldolgozást,
# és munkamenet -feldolgozás. Ha ez engedélyezve van, a PAM -hitelesítés megteszi
# a kbdinteractiveAuthentication és a
# Jelszó -hitelesítés.  A PAM konfigurációjától függően,
# A PAM hitelesítése a KBDInteractiveAuthentication segítségével megkerülheti
# Az "Permitrootlogin pass nélkül" beállítása.
# Ha csak azt akarja, hogy a PAM -fiók és a munkamenet -ellenőrzések nélkül futhassanak
# PAM hitelesítés, majd engedélyezze ezt, de állítsa be a jelszó -hitelesítés
# és a kbdinteractiveauthentication 'nem'.
# Engedélyezze az IGEN
# Engedélyezve az IGEN
# Gatewayports nem
# X11DisplayOffset 10
# X11USelocalHost igen
# Engedélyesség igen
# Printlastlog igen
# TCPEPEALIVE Igen
# PermitUserEnvironment No
# Késleltetett tömörítés
# ClientAliveInterVal 0
# ClientaliveCountMax 3
# Használt NO
# Pidfile /run/sshd.pid
# Maxstartups 10: 30: 100
# Permittunnel No
# Chrootdirectory Nincs
# VersionAddendum Nincs
# Nincs alapértelmezett banner elérési út
# Engedje meg, hogy az ügyfél átadja a Locale környezeti változóknak
# A nincs alrendszer alapértelmezett értékelése
# Példa a beállítások felülbírálására felhasználónkénti alapon
# Misling felhasználó anoncvs
# X11Forwarding No
# Engedélyező nem
# Engedélyezés nem
# ForceCommand CVS szerver

Ne feledje, hogy a fájl mentése a Ctrl+X és Y. Ezután írjunk egy Inicialize nevű alapvető szkriptet (mind a felhasználó alapértelmezett otthoni könyvtárában).

nano initialize

Adja hozzá ezeket a sorokat a fájlba, cserélveAz SSH gombjával macskával talált. (.SSH/ID_RSA.PUB)

# !/bin/bash

A fájlon átlépve, kezdje el soronként. Az első sor azt mondja a fordítónak, hogy ez egy bash szkript. Ezután telepítjük a függőségeket, az sshd_config másolását a megfelelő könyvtárba, az SSH újraindítását, az SSH -kulcsok root generálását, a felhasználó „Team" hozzáadását (ehhez a kedvelt nevet választhatja meg, használhatja az Adduser parancsot a nevükkel és a letiltott jelszavával). Hozzáadjuk a csapatot a Sudo csoporthoz, generáljuk az SSH -kulcsot, hozzáadjuk a kulcsunkat az engedélyezett kulcsokhoz és az övékhez is, és kinyomtatjuk a kulcsukat. Ez az új felhasználó az lesz, hogyan jelentkezzünk be a webhelyre.

Egy új terminálon menjen tovább, és nyissa meg újra a kiszolgálót.

ssh team@XX.XX.XX.XX

Ezúttal nem kell jelszóra, mivel SSH -kulcs. A jelszóval is letiltottuk a bejelentkezést, hogy a webhely biztonságosabb maradjon.

Most ez a szerver teljesen üres elindul, és nincs információ róla. Kezdjük azzal, hogy klónozzuk a projektünket a GIT -ből, hogy letölthessük és futtassuk a távoli gépen. Az SSH -hoz csatlakoztatott távoli szerveren először nyomtassa ki az SSH gombot:

cat ~/.ssh/id_rsa.pub

Ezután illessze be ezt a kulcsot a GIT -beállításokba, mint korábban, hogy beállítsuk a GIT -tárolónkat. Most klónozhatjuk a projektünket közvetlenül a szerverre. Ellenőrizze, hogy először biztonsági másolatot készített -e a projektről, így a GIT szerveren található.

git clone git://github.com/you/yourproject.git

Tökéletes. Most az összes fájl itt van. LS -vel láthatjuk őket

ls

Most kezdjük el a szerver beállítását. Először másolja át a projektkönyvtárat egy egyszerű, emlékezetes névbe, amelyet a projekthez használunk.

cp -r yourproject whatyoucalledit

Ahol a "WhatSyoUCALLEDIT" a projekt új neve. Ezután a szerver beállításához alapvető segédprogramot kell felépítenünk. Megmentjük ezt a segédprogramot, és a jövőben felhasználjuk. Ennek a segédprogramnak a felépítéséhez hozzunk létre egy felhasználói bináris fájlt, hogy meghatározzuk, hogyan szerkesztjük a szkriptet. Bash, szerkesztés/usr/bin/Ascript használatával

sudo nano /usr/bin/ascript

Ügyeljen arra, hogy ott használja a sudo -t, hogy engedélyekkel rendelkezzen a fájl szerkesztéséhez. A fájlba adja hozzá ezeket a sorokat:

# !/bin/bash
    echo "# !/bin/bash ">>/usr/bin/$ 1

Ne feledje, hogy ez a szkript egy érvelést, a szkriptnevet, mint 1 USD -t. Először ellenőrzi, hogy a fájl létezik -e, vagy más módon hozza létre, hozzáadja az első sort, amely a szkript bash -ja, megváltoztatja az engedélyeit, szerkeszti, és hozzáadja a nevét az /etc /AScripts -hez, amely lehetővé teszi, hogy tároljuk a létrehozott szkriptek nevét. Ha a fájl már létezik, egyszerűen módosítsa az engedélyeket és szerkessze. Mentse el a fájlt, és ezután megváltoztatjuk annak engedélyeit. Mindaddig, amíg ezt a szkriptet használjuk, ezt nem kell újra megtennünk.

sudo chmod a+x /usr/bin/ascript

Tökéletes. Hozzunk létre egy Setup nevű szkriptet. Először is, hogy ne tedd el, hanem nézd meg, hogy néz ki a beállítási szkriptem. Átmegyünk, hogy hogyan kell kinéznie ennek a szkriptnek a projektben, nem lesz szüksége a szkriptben, amellyel kezdeni kell.

# !/bin/bash
# sudo chmod a+x szkript/usersetup
# ./scripts/usersetup
# SSH-KeyGen
# Projektkönyvtár
# Naplóparancsok
# Nano konfiguráció
# Git config
# Frissítse és telepítse
# Engedélyezze a CLAMAV vírusos vírusát
# Állítsa be a gazdagépnevet
# Beállítás postgres
# Beállítási adatbázis biztonsági mentése
# Tiltsa le az iptables -t
# Telepítse a BitDefender -t
# Beállítás postfix
# DIR -k létrehozása
# Beállítás VirtualEnv
# Szerezd meg és építsük fel a függőségeket
# Állítsa be a tűzfalszabályokat
# Telepítse a PYPI -függőségeket
pip3 install --upgrade opencv-python # == 4.5.4.60
pip3 install --upgrade opencv-contrib-python # == 4.5.4.60
# PIP Install OpenCV-Python == 4.5.5.64
# PIP Install OpenCV-Contrib-Python == 4.5.5.64
# Telepítse a CERTBOT -ot
# Futtassa a certbotot
# Újratöltse a Mail Server újratöltését
# Másolja a tanúsítványokat
# sudo cp /etc/letsencrypt/live/femmebabe.com/privkey.pem privey.pem
# sudo cp /etc/letsencrypt/live/femmebabe.com/cert.pem cert.pem
# Patch Venv
# Állítsa be a felhasználói beállításokat
# Az engedélyek beállítása
# sudo chown -r csapat: felhasználók/var/run/
# sudo chown gyökér: gyökér/futás/sudo/ts -r
# sudo chmod 664 db.sqlite3
# sudo chown www-data: user db.sqlite3
# Másolja a konfigurációt és állítsa be az engedélyeket
# Beállítási adatbázis
# Injektáljon be a PAM konfigurát és távolítsa el a hibás SSH konfigurációt
# sudo sed -i '' -e '$ d' /etc/pam.d/sshd
# sudo sed -i '' -e '$ d' /etc /profil
# Másolja a tartály szkripteit és beállítja az engedélyeket
# A Szolgáltatások újratöltése és engedélyezése
# Engedélyezze az Apache modulokat
# sudo a2dismod mpm_event
# sudo a2dismod mpm_worker
# sudo a2enmod mpm_pefork
# Tiltsa le az alapértelmezett webhelyet
# Engedélyezze webhelyünket
# Töltse le újra a Daemon -ot, és indítsa újra az Apache, a Postfix és az OpendKim
# Az engedélyek beállítása
# Csere konfiguráció
# Init felirat motor
# Beállítás git
# Mutassa meg az IPv6 -ot és az OpendKim -t a domain konfigurációhoz
# A beállítás befejeződött

Ez sok beállítás! Röviden: ez a kódnaplók parancsok, konfigurálják a nano -t és a git -et, másolatokat másolnak, letöltenek és telepítenek az ubuntu apt csomagokat, a python függőségeket, konfigurálják a PostFix -et, konfigurálják a PostGresQL -t (az adatbázis -kiszolgáló), és betölti az adatbázist, az UFW -t (egy nem reklámcsillapítót), a letöltéseket, a letöltéseket, a letöltéseket, a clones -t függékeket, a Colones -t, a Colones -t, a Colones -t. A kiszolgálón, telepíti a konfigurációt, elindítja és engedélyezi a Sever, a Swap kiosztását, az engedélyeket beállítja, és kinyomtatja az IP, IPv6 címet és az OpenDKIM gombot. Meglehetősen egyszerű, de úgy néz ki, mint sok kód. Nem kell sok erre, mert nincs függőségünk, nem használunk zellert, celerybeat -ot vagy Daphne -t, de néhányat egyébként telepítünk az induláshoz. Vegye figyelembe, hogy ennek a kódnak többször deklarált domainje van.

Meg kell vásárolnunk egy domain nevet (ami egy kis éves díj). Ajánlom a Squarespace -t egy domain vásárlására, elrendezésük intuitív és könnyen használható. Bármely választott domaint megvásárolhat, de ebben a példában a femmebabe.com domaint használom. Miután megvásárolt egy tartományt, lépjen a Squarespace DNS konfigurációs panelen, és adjon hozzá egy rekordot, amely a tartományt mutatja a szerverhez IP -címen. Úgy kell kinéznie:

@ A xx.xx.xx.xx

A @ operátor mint gazdaszervezet, azaz az e domain alatti összes aldomain és a gyökér tartomány mind átirányítja a szerverre. Több nyilvántartást kell bejelenteni, de tovább léphetünk ezekre, ha készen állunk a levelek küldésére. Ne feledje, hogy néhány napot eltarthat, mielőtt sikeresen elküldheti a levelet a szerverről. A DNS -rekordok, amelyeket beállítottunk, időbe telik a szaporodás.

Különben is, az egyetlen rekord, amelyet el kell indítanunk, egy rekord. Tehát most kitölthetjük az alábbi szkriptet a projektünk szerint, és futtathatjuk.

Kezdjük egy kisebb beállítási szkripttel, hogy csak telepítsük azt, amire szükségünk van az alapvető előrehaladáshoz. Még nem használunk oly sok függőséget vagy a PostgreSQL -t, csak elindítunk egy alapvető HTTP -kiszolgálót, és aggódunk, hogy igazoljuk, amikor ez megtörtént. Ne feledje, hogy a HTTPS tanúsítvány megszerzéséhez és a szerver biztonságos futtatásához meg kell vásárolnunk egy tartományt a Rent A Server -rel együtt. Egyelőre cserélje ki a "Team" ebben a fájlban a felhasználó nevét, a "DIR" nevét a projekt könyvtárával, és adja meg az e -mailt és a tartományt a <> címkékben.

Ezenkívül, mielőtt ezt a kódot futtatnánk, meg kell változtatnunk a tűzfal beállításait, amelyeket a tárhely szolgáltató támogat. Általában ez a tárhely -szolgáltató „Networks" lapján található, vagy ha önálló tárhely, akkor az útválasztó „Port továbbítás" szakaszában van. Azt is be kell állítania egy statikus IP -t az útválasztón keresztül a szervergép címével, ha önálló tárhelyet használ. A következő portokat kell megnyitnia az olvasás/íráshoz való hozzáféréshez.

22 (SSH) 25 (levél) 587 (levél) 110 (Mail kliens) 80 (HTTP) 443 (HTTPS)

# !/bin/bash
# Naplóparancsok
# Nano konfiguráció
# Git config
# Frissítse és telepítse
# Engedélyezze a CLAMAV vírusos vírusát
# Állítsa be a gazdagépnevet
# Beállítási adatbázis biztonsági mentése
# Tiltsa le az iptables -t
# Beállítás VirtualEnv
# Telepítse a CERTBOT -ot
# Futtassa a certbotot
# Állítsa be a felhasználói beállításokat
# Az engedélyek beállítása
# sudo chown -r csapat: felhasználók/var/run/
# sudo chown gyökér: gyökér/futás/sudo/ts -r
# A Szolgáltatások újratöltése és engedélyezése
# Engedélyezze az Apache modulokat
# Töltse le újra a Daemon -ot, és indítsa újra az Apache, a Postfix és az OpendKim
# Mutassa meg az IPv6 -ot és az OpendKim -t a domain konfigurációhoz

A kód futtatása előtt ellenőrizze, hogy a megvásárolt tartomány csatlakozik -e a szerverhez. Ehhez nyisson meg egy terminált a helyi gépen, és futtassa ezt a parancsot a domainjével:

ping femmebabe.com # Helyezze ide a domainjét, ping után

Ha minden jól néz ki, és a kiszolgáló válaszokat küld, készen állunk a szkript futtatására és a csomagok telepítésére, valamint az Apache Server engedélyezésére és igazolására.

Ez nem az összes beállítás, amely a Postfix konfigurálásához szükséges, később ezt a beállítást később megvizsgáljuk. Egyelőre futtassa ezt a beállítási kódot, és néhány percig tarthat a szerver telepítése és tanúsítása. Még egyszer, feltétlenül cserélje ki a Név, az e -mail és a domain nevet a szkriptben a megvásárolt név szerint.

Most, hogy a szerver kiszolgálva van, bármely webböngészőben léphet fel az URL -be, és ellenőrizheti, hogy a szerver HTTPS -t futtatja -e. Ha nem, próbáljon meg egy kicsit várni egy kicsit, hogy a DNS Records felzárkózjon, majd futtassa a következő parancsot a CertBot tanúsítás újbóli újbóli megismétléséhez:

sudo certbot --apache --non-interactive --agree-tos --domains <domain>.com --email <youremail>@gmail.com

Mindaddig, amíg mindent helyesen konfigurált, akkor hozzáférhet az Apache alapértelmezett oldalához, csak hogy megtudja, hogy a kód működik, és megjelenik egy élő weboldalon. Ezután szerkesszük a suttings.py -t, hogy az alapértelmezett hibakeresési módot a produkcióra változtassuk. A tartományt a beállításokban, valamint a belső IP -kben is konfiguráljuk.

nano yourproject/settings.py

A beállításokban módosítsa/adja hozzá ezeket a sorokat.

# Helyszíni konfiguráció

Most konfigurálnunk kell az Apache2 -t. Szerkesszük a konfigurációs fájlt, amelyet ezzel a sorral telepítünk:

sudo nano /etc/apache2/sites-available/femmebabe-le-ssl.conf

Ennek a konfigurációs fájlnak a domain nevünknek, valamint a felhasználó és a projekt nevének kell lennie. A femmebabe.com domain nevet, a felhasználónév csapatát és a Femmebabe projekt nevét használom.

ServerSignature Off
ServerTokens Prod
<IfModule mod_ssl.c>
<VirtualHost *:80> 
	Redirect permanent / https://femmebabe.com/
</VirtualHost>
<VirtualHost *:443>
	ServerName femmebabe.com
	ServerAdmin team@femmebabe.com
	DocumentRoot /var/www/html

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined
	
	Alias /static /home/team/femmebabe/static
	<Directory /home/team/femmebabe/static>
		Require all granted
	</Directory>

Alias /media/icons /home/team/femmebabe/media/
<Directory /home/team/femmebabe/media>
Require all granted
</Directory>

	<Directory /home/team/femmebabe/femmebabe>
		<Files wsgi.py>
			Require all granted
		</Files>
	</Directory>

	WSGIScriptAlias / /home/team/femmebabe/femmebabe/wsgi.py
	WSGIDaemonProcess femmebabe python-path=/home/team/femmebabe/ python-home=/home/team/femmebabe/venv header-buffer-size=100000000000 user=team
	WSGIProcessGroup femmebabe
	WSGIApplicationGroup %{GLOBAL}
	
	<Directory /home/team/femmebabe/static>
                Options Indexes FollowSymLinks
                AllowOverride All
	</Directory>

	<IfModule mod_rewrite.c>
		RewriteEngine on
		RewriteCond %{REQUEST_URI} \.(css|webp|webm|gif|png|mp3|wav|jpeg|jpg|svg|webp)$ [NC]
		RewriteCond %{HTTP_REFERER} !^https://femmebabe.com/media/.*$ [NC]
		RewriteRule ^(.+?)/$ /media/$1 [F,L]
	</IfModule>

	Include /etc/letsencrypt/options-ssl-apache.conf
	SSLCertificateFile /etc/letsencrypt/live/femmebabe.com/fullchain.pem
	SSLCertificateKeyFile /etc/letsencrypt/live/femmebabe.com/privkey.pem

	Header set X-Frame-Options: "SAMEORIGIN"
	Header set Access-Control-Allow-Origin "https://femmebabe.com"

	TimeOut 60000
	LimitRequestBody 0

	<FilesMatch ".(ico|pdf|flv|jpg|jpeg|png|gif|webp|JPG|JPEG|wav|mp3|mp4|public|js|css|swf|webp|svg)$">
		Header set Cache-Control "max-age=30, public"
	</FilesMatch>
</VirtualHost>
</IfModule>
<IfModule mod_ssl.c>
<VirtualHost *:80>
	ServerName femmebabe.com
	ServerAdmin team@femmebabe.com
	DocumentRoot /var/www/html

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined

	RewriteEngine on
	RewriteCond %{SERVER_NAME} =femmebabe.com
	RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>
</IfModule>

Ügyeljen arra, hogy cserélje ki a projekt nevét, a könyvtárakat és a tartományt ebben a példakódban, amikor a szerver konfigurálásakor. Most le kell tiltanunk az alapértelmezett webhelyet. Ez megtehető a bash használatával.

sudo a2dissite 000-default-le-ssl
sudo a2dissite 000-default
sudo a2dissite default-ssl

Ezután engedélyezhetjük az alapértelmezett webhelyet és újratölthetjük az Apache2 -t, a bash használatával is. Ne felejtse el kicserélni a femmebabe-t a fájl nevével, amelyet az/etc/Apache2/webhelyek szerkesztése során deklarált/.

sudo a2ensite femmebabe-le-ssl
sudo systemctl reload apache2

Menj vissza a domainjéhez a navigációs bárban. Látnia kell a webes böngészőben konfigurált webhelyet. Gratulálok! Ha nem látja, akkor lehet, hogy meg kell változtatnia néhány változtatást. Óvatosan olvassa el a projekt beállításait, az Apache konfigurációját, és győződjön meg arról, hogy nincs hibája, és futtassa a következő parancsokat a projekt hibáinak ellenőrzéséhez.

cd projectname
source venv/bin/activate
python manage.py check

Ha hibái vannak a Python -projektben, nyomon kövesse őket, ahol vannak, és javítsa meg őket. Lehet, hogy nem látja az összes hibát, attól függően, hogy hol van, tehát ha olyan hiba van, amely egyszerűen azt mondja, hogy "Popule nem reentant", szerkessze a következő fájlt a virtuális környezetben, a regisztráció.py, hogy felfedje a hibát.

nano venv/lib/python3.12/site-packages/django/apps/registry.py

Görgessen a 83. sorba, ahol felmerül ez a futási idő (emelje fel a RunTimeError ("Popule () nem reentant")), és adjon hozzá egy megjegyzést e sor előtt, majd hozzáadja, ugyanazzal a bemélyedéssel, self.app_configs = {}. Ez így néz ki:

                # A Reentrant hívások megakadályozása az appConfig.ready () futtatásának elkerülése érdekében
                # Módszerek kétszer.
# emelje fel a RunTimeError ("Popule () nem reentrant")

Ezután újra ellenőrizheti a projektet, és feltárhatja a hibát.

python manage.py check

Ezután láthatja a hibát, és kijavíthatja. Ha rögzítve van, és a kód hiba nélkül áll össze, ügyeljen arra, hogy a fájlt visszaállítsa, így így néz ki:

                # A Reentrant hívások megakadályozása az appConfig.ready () futtatásának elkerülése érdekében
                # Módszerek kétszer.
# self.app_configs = {}

Feltéve, hogy a szerver online van, amikor további változtatásokat hajtunk végre, a következő parancsot kell használni a szerver újratöltéséhez:

sudo systemctl reload apache2

Döbbenetes! De mi van a levelek küldésével? Az e -mail küldésének megkezdéséhez először frissítenünk kell a domain konfigurációt. Ennek a Squarespace -i DNS -panelben kell lennie, vagy bármilyen domain név regisztrátornak. A konfigurációt is telepítenünk és hozzá kell adnunk, és futtatnunk kell néhány parancsot.

Először szerezzük be a szerver IPv6 címét. Ezután megnyitjuk a DNS -t, és hozzáadjuk a rekordokat.

A szerver IPv6 címének megszerzéséhez használja ezt a parancsot:

ip -6 addr

Most hozzáadhatjuk a következő rekordokat a DNS -beállításokhoz. A lemezeim így néznek ki. A nyilvántartásaihoz azonban az IP -címet cserélje ki az IP -vel (nem 75.147.182.214, ez az enyém). Adja hozzá a domainjét a femmebabe.com helyett is, valamint az előző paranccsal talált IPv6 -címet (nem használhatja az enyémet, Fe80 :: 725a: FFF: FE49: 3E02). Ne aggódjon a domainKey miatt, ez akkor jön létre, amikor beállítjuk a Postfix, a Mail Server, az OpEdKim segítségével, és kinyomtassuk a kulcsot. Konfiguráljuk ezt az utolsóat.

@ A N/A 75.147.182.214

@ MX 10 femmebabe.com

@ PTR N/A femmebabe.com

@ Txt N/A TXT @ V = SPF1 MX IP75.147.182.214IP6: FE80 :: 725A: FFF: FE49: 3E02 ~ All

alapértelmezett._bimi Txt N/A v = bimi1; l = https: //femmebabe.com/media/static/femmebabe.svg

_DMARC Txt N/A v = dmarc1; p = nincs

sendonly._domainkey Txt N/A

Most hozzá kell adnunk néhány tartós konfigurációt a Postfixhez. Csak annyit kell tennünk, hogy megbizonyosodjunk arról, hogy kicseréljük a femmebabe.com domain nevet az Ön által használt domain névvel. Nézzük meg az összes konfigurációs fájlt egyenként, és telepítsük azokat egy konfigurációs könyvtárba, a projektünkbe, hogy telepítsük az operációs rendszert.

nano config/etc_postfix_main.cf

Adja hozzá ezt a szöveget a fájlhoz

# A kommentált, teljesebb verzióért lásd az /usr/share/postfix/main.cf.dist
# Debian -specifikus: A fájlnév megadása az első okozza
# a névként használható fájl sora.  A Debian alapértelmezett
# van /etc /MailName.
# myorigin = /etc /MailName
# Hozzáadás. A domain a MUA feladata.
# A "késleltetett levelek" figyelmeztetések generálásához a következő sorban a következő sor
# Deleal_warning_time = 4h
# Lásd: http://www.postfix.org/compatibility_readMe.html - alapértelmezett a 3.6 -ra
# Friss telepítések.
# TLS paraméterek
# Milter konfiguráció

Következő konfiguráció!

nano config/etc_postfix_master.cf

Adja hozzá ezeket a sorokat:

# 
# PostFix Master Process Configuration File.  A formátum részleteiért
# A fájlból lásd a Master (5) Kézi oldalt (parancs: "Man 5 mester" vagy
# On-line: http://www.postfix.org/master.5.html).
# 
# Ne felejtse el végrehajtani a "PostFix Reload" végrehajtását a fájl szerkesztése után.
# 
# ======================================================================================================
# Szolgáltatás típusa Privát, Chroot Wakeup MaxProc parancs + args
# (Igen) (igen) (nem) (soha) (100)
# ======================================================================================================
# smtp inet n - y - 1 utánsóképernyő
# smtpd pass - - y - - smtpd
# dnsblog unix - - y - 0 dnsblog
# tlsproxy unix - - y - 0 tlsproxy
# Válasszon egyet: Engedélyezze a benyújtást csak a loopback ügyfelek számára, vagy bármely ügyfél számára.
# 127.0.0.1:submission inet n - y - - smtpd
# -o syslog_name = posztfix/benyújtás
# -o smtpd_tls_security_level = titkosítás
# -o smtpd_sasl_auth_enable = igen
# -o smtpd_tls_auth_only = igen
# -o smtpd_reject_unlister_recipient = no
# -o smtpd_client_restrictions = $ mua_client_restrictions
# -o smtpd_helo_restrictions = $ mua_helo_restrictions
# -o smtpd_sender_restrictions = $ mua_sender_restrictions
# -o smtpd_recipient_restrictions =
# -o smtpd_relay_restrictions = permit_sasl_authentiketed, utasítás
# -o milter_macro_daemon_name = eredet
# Válasszon egyet: Engedélyezze az SMTP -ket csak a visszacsatolás ügyfelek számára, vagy bármely ügyfél számára.
# 127.0.0.1:smtps inet n - y - - smtpd
# smtps inet n - y - - smtpd
# -o syslog_name = posztfix/smtps
# -o smtpd_tls_wrapperMode = igen
# -o smtpd_sasl_auth_enable = igen
# -o smtpd_reject_unlister_recipient = no
# -o smtpd_client_restrictions = $ mua_client_restrictions
# -o smtpd_helo_restrictions = $ mua_helo_restrictions
# -o smtpd_sender_restrictions = $ mua_sender_restrictions
# -o smtpd_recipient_restrictions =
# -o smtpd_relay_restrictions = permit_sasl_authentiketed, utasítás
# -o milter_macro_daemon_name = eredet
# 628 inet n - y - - qmqpd
# qmgr unix n - n 300 1 oqmgr
# -o smtp_helo_timeout = 5 -o smtp_connect_timeout = 5
# 
# ===============================================================
# Interfészek a nem Postfix szoftverekhez. Feltétlenül vizsgálja meg a kézikönyvet
# A nem Postfix szoftver oldalai, hogy megtudják, milyen lehetőségeket akarnak.
# 
# A következő szolgáltatások közül sok a Postfix cső (8) kézbesítését használja
# ügynök.  Lásd a Pipe (8) Man oldalt a $ {címzett} -ről szóló információkért
# és egyéb üzenet boríték beállításai.
# ===============================================================
# 
# Maildrop. A részletekért lásd a Postfix Maildrop_readMe fájlt.
# A Main.CF -ben is megadja: Maildrop_destination_recipient_limit = 1
# 
# 
# ===============================================================
# 
# A legfrissebb Cyrus verziók használhatják a meglévő "LMTP" Master.cf bejegyzést.
# 
# Adja meg a cyrus.conf oldalt:
# LMTP CMD = "LMTPD -A" LIST = "LocalHost: LMTP" Proto = TCP4
# 
# Adja meg a main.cf fájlt az alábbiak közül egy vagy több:
# Mailbox_transport = lmtp: inet: localhost
# virtual_transport = lmtp: inet: localhost
# 
# ===============================================================
# 
# Cyrus 2.1.5 (Amos Gouaux)
# A main.CF -ben is megadja: cyrus_destination_recipient_limit = 1
# 
# Cyrus unix - n n - - cső
# Flags = DRX felhasználó = cyrus argv =/cyrus/bin/delising -e -r $ {sender} -m $ {kiterjesztés} $ {user}
# 
# ===============================================================
# Régi példa a Cyrus -on keresztüli szállításra.
# 
# Old -cyrus unix - n n - - cső
# Flags = R felhasználó = cyrus argv =/cyrus/bin/delising -e -m $ {kiterjesztés} $ {felhasználó}
# 
# ===============================================================
# 
# A konfigurációs részletekért lásd a Postfix UUCP_README fájlt.
# 
# 
# Egyéb külső szállítási módszerek.
# 

És az OpendKim konfiguráció. Az OpenDKIM azonosítja az e -mail szervereket a domain kulcsokkal, hogy biztonságosabbá tegyék őket. Enélkül a Mail nincs aláírva, és lehet, hogy nem jut be a postaládába.

nano config/etc_default_opendkim

Adja hozzá ezeket a sorokat:

# Megjegyzés: Ez egy Legacy konfigurációs fájl. Az OpendKim nem használja
# SystemD szolgáltatás. Kérjük, használja a megfelelő konfigurációs paramétereket
# /etc/opendkim.conf helyette.
# 
# Korábban itt szerkeszthetjük az alapértelmezett beállításokat, majd végrehajtsák
# /lib/opendkim/opendkim.service.generate a SystemD felülbíráló fájlok előállításához
# /etc/systemd/system/opendkim.service.d/override.conf és
# /etc/tmpfiles.d/opendkim.conf. Bár ez még mindig lehetséges, most van
# Javasoljuk, hogy a beállításokat közvetlenül az /etc/opendkim.conf alkalmazásban módosítsa.
# 
# Daemon_opts = ""
# Váltás/var/spool/postfix/run/opendkim váltáshoz Unix aljzat használatához
# Postfix chrootban:
# Rundir =/var/spool/postfix/run/opendkim
# 
# Alternatív aljzat megadása
# Vegye figyelembe, hogy ennek beállítása felülbírálja az opendkim.conf bármely aljzatértékét
# Alapértelmezés:
# Hallgassa meg az 54321 port minden interfészét:
# Socket = inet: 54321
# Hallgassa meg a Loopback -ot a 12345 -es porton:
# Socket = inet: 12345@localhost
# Hallgassa meg a 192.0.2.1 -et a 12345 -es porton:
# Socket = inet: 12345@192.0.2.1

nano config/etc_dovecot_conf.d_10-master.conf

Adja hozzá ezeket a sorokat:

# defenult_process_limit = 100
# DEFAULT_CLIENT_LIMIT = 1000
# Alapértelmezett VSZ (virtuális memória méret) korlátja a szolgáltatási folyamatokhoz. Ez főleg az
# arra törekszik, hogy elkapja és megölje azokat a folyamatokat, amelyek szivárognak a memória előtt, mielőtt megeszik
# minden.
# DEFAULT_VSZ_LIMIT = 256m
# A bejelentkezési felhasználót a bejelentkezési folyamatok belsőleg használják. Ez a legbízásosabb
# Felhasználó a Dovecot rendszerben. Ennek egyáltalán nem szabad hozzáférni.
# DEFAULT_LOGIN_USER = DOVENULL
# A belső felhasználót a nem privhatatlan folyamatok használják. El kell különítenie a
# Jelentkezzen be a felhasználó, hogy a bejelentkezési folyamatok ne zavarjanak más folyamatokat.
# DEFAULT_INTERNAL_USER = DOVECOT
    # port = 143
    # port = 993
    # SSL = Igen
  # Az új folyamat megkezdése előtt kezelendő kapcsolatok száma. Jellemzően
  # Az egyetlen hasznos érték a 0 (korlátlan) vagy az 1. 1 -es érték biztonságosabb, de 0
  # gyorsabb. <doc/wiki/loginprocess.txt>
  # service_count = 1
  # A folyamatok száma, amelyek mindig várnak további kapcsolatokra.
  # Process_min_avail = 0
  # Ha beállítja a service_count = 0 -t, akkor valószínűleg ezt meg kell termesztenie.
  # vsz_limit = $ default_vsz_limit
    # port = 110
    # port = 995
    # SSL = Igen
    # port = 587
  # Csak akkor hozzon létre inet hallgatót, ha nem tudja használni a fenti Unix aljzatot
  # inet_listener lmtp {
    # Kerülje az LMTP láthatóvá tételét az egész interneten
    # Cím =
    # port =
  # }
  # A memória nagy része az mmap () ING fájlokra kerül. Lehet, hogy ezt meg kell növelnie
  # Limit, ha hatalmas postafiókjai vannak.
  # vsz_limit = $ default_vsz_limit
  # Max. Az IMAP folyamatok száma (kapcsolatok)
  # Process_limit = 1024
  # Max. A POP3 folyamatok száma (kapcsolatok)
  # Process_limit = 1024
  # Max. Az SMTP benyújtási folyamatok száma (kapcsolatok)
  # Process_limit = 1024
  # Az auth_socket_path alapértelmezés szerint rámutat erre a felhasználó -aljzatra. Általában az
  # a dovecot-lda, a doveadm, az esetlegesen imap folyamat stb.
  # Az aljzat teljes engedélye megszerezheti az összes felhasználónév listáját és
  # Szerezd meg mindenki felhasználó -keresésének eredményeit.
  # 
  # Az alapértelmezett 0666 mód lehetővé teszi bárkinek, hogy csatlakozzon az aljzathoz, de a
  # A UserDB keresések csak akkor sikeresek lesznek, ha a UserDB egy "UID" mezőt ad vissza.
  # Megfelel a hívó fél folyamata UID -jének. Szintén, ha a hívó fél UID vagy GID megegyezik a
  # Socket UID vagy gid a keresés sikeres. Bármi más kudarcot okoz.
  # 
  # Annak érdekében, hogy a hívó fél teljes engedélye legyen az összes felhasználó kereséséhez, állítsa be a módot
  # valami más, mint a 0666, és a Dovecot lehetővé teszi a kernel végrehajtását
  # Engedélyek (például a 0777 mindenki számára lehetővé teszik a teljes engedélyeket).
  # Az Auth Worker folyamatát alapértelmezés szerint gyökérként futtatják, hogy hozzáférhessen
  # /etc/árnyék. Ha ez nem szükséges, akkor a felhasználót meg kell változtatni
  # $ defalult_internal_user.
  # user = gyökér
  # Ha DICT proxyt használnak, a postai folyamatoknak hozzáférniük kell a foglalatához.
  # Például: MODE = 0660, Group = Vmail és Global Mail_access_groups = Vmail
    # mód = 0600
    # felhasználó =
    # csoport =

Még egyszer, ügyeljen arra, hogy cserélje ki a tartományt az összes fájlban, a femmebabe.com -ban a kiválasztott domainnel. Szerkessze a következő fájlt, a Dovecot's Config,

nano config/etc_dovecot_dovecot

És adja hozzá ezeket a sorokat

## Dovecot konfigurációs fájl
# Ha sietsz, lásd: http://wiki2.dovecot.org/quickConfiguration
# A "Doveconf -n" parancs tiszta kimenetet ad a megváltozott beállításokról. Használja
# A fájlok másolása és beillesztése helyett a DoveCot levelezőlistára való közzétételkor.
# '# - Karakter és minden, miután megjegyzésként kezelik. Extra terek
# és a füleket figyelmen kívül hagyják. Ha ezek egyikét kifejezetten szeretné használni, tedd a
# value inside quotes, eg.: key = "# Char és Training Whitespace "
# A legtöbb (de nem minden) beállítást különféle protokollok és/vagy
# Forrás/cél IPS a beállítások szakaszokba helyezésével, például:
# Protokoll IMAP {}, Local 127.0.0.1 {}, Remote 10.0.0.0/8 {}
# Az alapértelmezett értékeket az egyes beállítások esetében nem kell megkönnyíteni
# azok. Ezek azonban kivételek: Nincs szakasz (például névtér {})
# vagy a plugin beállításait alapértelmezés szerint adják hozzá, csak példákként vannak felsorolva.
# Az útvonalak csak példák is, a valódi alapértelmezések a konfigurán alapulnak
# Opciók. Az itt felsorolt ​​útvonalak a konfiguráláshoz -prefix =/usr
# --sysconfdir =/etc-localstatedir =/var
# Engedélyezze a telepített protokollokat
# Vessző elválasztott listája az IP -knek vagy a házigazdáknak, ahol hallgatni lehet a kapcsolatokhoz.
# "*" Az összes IPv4 interfészben meghallgatja "::" Az összes IPv6 interfészben meghallgatja.
# Ha meg szeretné határozni a nem alapértelmezett portokat vagy bármi összetettebbet,
# szerkesztés conf.d/master.conf.
# Figyelj = *, ::
# Alapkönyvtár, ahol tárolhatja a futásidejű adatokat.
# base_dir =/var/run/dovecot/
# Ennek a példánynak a neve. A multi-instance beállításban a Doveadm és más parancsok
# használhatja a -i <példány_name> kiválasztásához, melyik példányt használja (alternatíva
# to -c <config_path>). A példány neve hozzáadódik a Dovecot folyamatokhoz is
# A PS kimenetben.
# példány_name = dovecot
# Üdvözlet üzenet az ügyfelek számára.
# login_greeting = Dovecot kész.
# A megbízható hálózati tartományok helyét elválasztott listája. Kapcsolatok ezekből
# Az IP -k megengedhetik, hogy felülbírálják IP -címeiket és portjaikat (a naplózáshoz és
# hitelesítési ellenőrzésekhez). disable_plaintext_auth is figyelmen kívül hagyják
# Ezek a hálózatok. Általában itt adja meg az IMAP proxy -kiszolgálóit.
# login_trusted_networks =
# A bejelentkezési hozzáférés ellenőrző aljzatok (például a TCPWRAP) helyét elválasztott listája
# login_access_sockets =
# A proxy_maybe -vel = igen, ha a proxy rendeltetési hely megegyezik ezen IP -k bármelyikével, ne tegye
# proxying. Ez általában nem szükséges, de hasznos lehet, ha a rendeltetési hely
# Az IP pl. A terheléselosztó IP -je.
# auth_proxy_self =
# Mutasson több szóbeli folyamatcímet (a PS -ben). Jelenleg a felhasználónevet és
# IP -cím. Hasznos látni, hogy ki valójában az IMAP folyamatokat használja
# (pl. Megosztott postafiókok, vagy ha ugyanazt az UID -t használják több fiókhoz).
# verbose_proctitle = nem
# Ha minden folyamatot el kell ölni, amikor a Dovecot Master folyamat leáll.
# Ennek "nem" -re állítása azt jelenti, hogy a doveCot frissíthető
# a meglévő ügyfélkapcsolatok bezárására kényszerítése (bár ez is lehet
# probléma, ha a frissítés pl. biztonsági javítás miatt).
# Shutdown_clients = igen
# Ha nem nulla, futtassa a Mail parancsokat ezen a sok kapcsolaton keresztül a DoveAdm Server-hez,
# Ahelyett, hogy közvetlenül ugyanabban a folyamatban futtatnák őket.
# doveadm_worker_count = 0
# Unix aljzat vagy gazdagép: A Port használja a DoveAdm szerverhez való csatlakozáshoz
# doveadm_socket_path = doveadm-server
# A Dovecot -on megőrzött környezeti változók helyét elválasztott listája
# indítás és átadta az összes gyermek folyamatának. Ön is adhat
# Key = értékpárosok, hogy mindig beállítsák a konkrét beállításokat.
# import_environment = tz
## 
## Szótárkiszolgáló beállításai
## 
# A szótár használható a kulcs = értéklisták tárolására. Ezt több használja
# plugins. A szótár közvetlenül vagy bár a
# Szótár szerver. A következő dikt -blokk a szótárneveket az URI -hez térképezi fel
# A szerver használatakor. Ezeket az URIS formátumban történő hivatkozására lehet hivatkozni
# "Proxy :: <név>".
  # kvóta = mysql: /etc/dovecot/dovecot-dict-sql.conf.ext
# A tényleges konfiguráció nagy részét az alábbiakban tartalmazzák. A fájlnevek
# Először az ASCII -értékük szerint rendezték, és ebben a sorrendben elemezték. A 00-Terrexes
# A fájlnevekben a megrendelés megkönnyítésére szolgál.
# Egy konfigurációs fájl megpróbálta beilleszteni a hibát is, ha
# Nem található:
# Lehetővé teszi a Dovecot számára, hogy meghallgassa az összes bemeneti kapcsolatot (IPv4 / IPv6)

Adjon hozzá egy jelszót a Dovecot felhasználó számára:

nano config/etc_dovecot_passwd

A fájl első része, a vastagbél előtt, a felhasználónév. Az utolsó rész, a "YourPassword" jelszót jelöli, amelyet szeretne adni a levelező szerverének.

team:{plain}yourpassword

Ezután az OpendKim config

nano config/etc_opendkim.conf

És add hozzá ezeket a sorokat:

# Ez egy alapvető konfiguráció az aláíráshoz és az ellenőrzéshez. Könnyen lehet
# az alapvető telepítéshez igazítva. Lásd az opendKim.conf (5) és
# /usr/share/doc/opendkim/examples/opendkim.conf.sample a teljes
# A rendelkezésre álló konfigurációs paraméterek dokumentálása.
# Logwhy nem
# Általános aláírási és ellenőrzési paraméterek. Debianban a "From" fejléc
# megsemmisült, mert gyakran az a személyazonossági kulcs, amelyet a hírnév rendszerek használnak
# és így kissé érzékeny.
# Aláírási tartomány, választó és kulcs (kötelező). Például végezzen aláírást
# A "Példakénti.com" domain "2020" (2020._domainkey.example.com) választóhoz,
# Az /etc/dkimkeys/example.private -ben tárolt privát kulcs használatával. Szemcsésebb
# A beállítási lehetőségek megtalálhatók a /usr/share/doc/opendkim/readme.opendkim oldalon.
# Domain példa.com
# 2020 -as választó
# Keyfile /etc/dkimkeys/example.private
# Debianban az OpendKim felhasználói "OpendKim" -ként fut. A 007 -es oMask szükséges, amikor
# egy helyi aljzat használata MTA-kkal, amelyek nem privilegedként férnek hozzá a foglalathoz
# Felhasználó (például Postfix). Előfordulhat, hogy hozzá kell adnia a "Postfix" felhasználót a csoportba
# "Opendkim" ebben az esetben.
# Az MTA csatlakozás aljzata (kötelező). Ha az MTA egy chroot börtönben van,
# Gondoskodni kell arról, hogy az aljzat hozzáférhető legyen. A Debianban a Postfix fut be
# egy chroot a/var/orsó/posztfix in -ben, ezért egy Unix aljzatnak kell lennie
# konfigurálva az alábbi utolsó sorban látható módon.
# Socket Local: /run/opendkim/opendkim.sock
# Socket inet: 8891@localhost
# Aljzat inet: 8891
# Azok a gazdagépek, amelyekre az ellenőrzés helyett aláírni kell, az alapértelmezés 127.0.0.1. Lásd a
# További információkért az OpendKim (8) működési szakasza.
# Internalhosts 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12
# A bizalmi horgony lehetővé teszi a DNSSEC -t. Debianban a bizalmi horgonyfájl rendelkezésre áll
# a DNS-Root-Data csomagot.
# Nameservers 127.0.0.1
# Térkép -tartományok a címekről az üzenetek aláírására használt kulcsokig
# Belső házigazdák sorozatát, amelynek leveleit alá kell írni

nano config/etc_default_opendkim

És adja hozzá ezeket a sorokat

# Megjegyzés: Ez egy Legacy konfigurációs fájl. Az OpendKim nem használja
# SystemD szolgáltatás. Kérjük, használja a megfelelő konfigurációs paramétereket
# /etc/opendkim.conf helyette.
# 
# Korábban itt szerkeszthetjük az alapértelmezett beállításokat, majd végrehajtsák
# /lib/opendkim/opendkim.service.generate a SystemD felülbíráló fájlok előállításához
# /etc/systemd/system/opendkim.service.d/override.conf és
# /etc/tmpfiles.d/opendkim.conf. Bár ez még mindig lehetséges, most van
# Javasoljuk, hogy a beállításokat közvetlenül az /etc/opendkim.conf alkalmazásban módosítsa.
# 
# Daemon_opts = ""
# Váltás/var/spool/postfix/run/opendkim váltáshoz Unix aljzat használatához
# Postfix chrootban:
# Rundir =/var/spool/postfix/run/opendkim
# 
# Alternatív aljzat megadása
# Vegye figyelembe, hogy ennek beállítása felülbírálja az opendkim.conf bármely aljzatértékét
# Alapértelmezés:
# Hallgassa meg az 54321 port minden interfészét:
# Socket = inet: 54321
# Hallgassa meg a Loopback -ot a 12345 -es porton:
# Socket = inet: 12345@localhost
# Hallgassa meg a 192.0.2.1 -et a 12345 -es porton:
# Socket = inet: 12345@192.0.2.1

Amikor készen állunk a PostFix szerver beállítására, az alábbi kódot futtatjuk, a megfelelő tartománynév beágyazva. Kezdje a szkript létrehozásával

touch scripts/postfixsetup
sudo chmod a+x scripts/postfixsetup
nano scripts/postfixsetup

Most, a Nano -ban, a szövegszerkesztőben szerkessze ezt a fájlt, így a femmebabe.com helyett a domain nevét tartalmazza.

# !/bin/bash
# Beállítás postfix

Most futtassa a kitöltött szkriptet a Postfix, az OpendKim és a Dovecot konfigurálásához.

./scripts/postfixsetup

Miután ez a szkript futtatta, másolja az utolsó sort, amelyet kinyomtat, és beilleszti a DNS -konfigurációba, mint a sendonly._domainKey értékét. Ez az OpendKim kulcs, amelyet a domain azonosításához használnak, amikor biztonságos leveleket küldenek.

Döbbenetes! Néhány napon belül képesnek kell lennie arra, hogy leveleket küldjön a szerverről, feltéve, hogy minden helyesen van konfigurálva.

Ha csak konfigurálta a DNS -t a levelező szerveréhez, akkor kevesebb, mint 72 órát vesz igénybe, amíg a rekordok frissülnek. Általában sokkal gyorsabb. Ellenőrizheti, hogy a szerver működik -e ennek a parancsnak a használatával, megadta az e -mailt:

echo "test" | mail -s "Test Email" youremail@gmail.com

Ha úgy tűnik, hogy minden helyesen működik, akkor képesnek kell lennie arra, hogy e -mailt küldjön a szerverével. Ha ez nem működik, próbálja meg megnézni a naplókat, hogy megnézze, mi lehet a hiba.

tail –lines 150 /var/log/mail.log

Ez szóbeli információkat kínál a kiszolgáló által küldött levelekről és arról, hogy megfelelően működik -e. Képesnek kell lennie arra, hogy az e -mailt is látja a postaládájában, ha nincs ott, ellenőrizze a spam mappát.

A beállítások beállításait is be kell állítania a beállítások.py webhelyen, hogy az e -mail szerver beszélhessen a Django alkalmazásával, a projektjével. Adja hozzá vagy cserélje ki ezeket a sorokat a beállításokba

EMAIL_HOST_USER = 'team' # 'Love@mamasheen.com'

Vegye figyelembe, hogy konfigurációs fájlt használunk a jelszó megszerzéséhez. Töltsük be ezt a fájlt a beállításokba, a fájl elején::

# Nyissa meg és töltse be a konfigurációt

Készítsük el ezt a fájlt, és adjunk hozzá egy titkos kulcsot, valamint az e -mail jelszót. Titkos kulcs generálásához használja ezt a parancsot, bármilyen hosszúságú, a végén:

openssl rand -base64 64

Most másolja át az OpenSSL generált szöveget és szerkesztje az /etc/config.json -t

sudo nano /etc/config.json

Adja hozzá a következő sorokat a fájljához, azzal a kulccsal, amelyet az OpenSSL generált titkos kulcsként.

{
	"SECRET_KEY": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXX-generated-using-openssl)",
	"EMAIL_HOST_PASSWORD": "yourpassword"
}

A JSON formátum egyszerű és könnyen használható, más kulcsokat is kijelenthetünk, amelyeket a projektünkben is használni akarunk, és külön -külön tarthatjuk őket a projektkönyvtáraktól, hogy más felhasználók ne írjanak nekik, és így nem olvashatók csak a projektkönyvtárból. Ez a javasolt gyakorlat az API -kulcsok számára, amelyek közül néhányat itt fogunk használni.

Biztonsági másolatot kell készítenie a projektről, hogy megbizonyosodjon arról, hogy minden menthető -e, és később is visszaállíthatja munkáját, még akkor is, ha már nem akarja bérelni egy szerveret.

sudo backup

Most próbáljon el küldeni egy HTML e -mailt a webszerverről, feltéve, hogy a parancssorból való küldést működteti. Kérdezze meg a felhasználói példányt a héjban, és küldjön egy HTML e -mailt a felhasználó számára a Django segítségével. Változtassa meg a nevemet a kódban, Charlotte -ban a felhasználónevedre.

python manage.py shell
from django.contrib.auth.models import User
u = User.objects.get(username='Charlotte')
from users.email import send_welcome_email
send_welcome_email(u)
exit()

Ha az első parancs nem működik, feltétlenül használja

source venv/bin/activate

Feltéve, hogy minden helyesen van beállítva, most egy üdvözlő e -mailt kap a webes alkalmazás által küldött postafiókjában. Jó munka! Hosszú utat tettél.

Hozzá akartam adni, ha egyáltalán küzdenek bármilyen hibával, miközben egy ilyen projekten dolgoznak, ne habozzon keresni a választ és kérjen segítséget. A Google, többek között a keresőmotorok, nagyszerű források a programozási segítség kereséséhez. Egyszerűen keresse meg a kapott hibát, és láthatja, hogy mások hogyan oldják meg a problémát. Ezenkívül szívesen felveszi a kapcsolatot velem, az oktatókkal (tanárok, professzorok, oktatók), az interneten lévő társakkal, akik programozási segítségre állnak, vagy újra konzultálnak ezzel a könyvvel, vagy más erőforrásokkal, hogy megoldásokat találjanak a tapasztalt problémákra. Megértem, hogy ez nem könnyű, de még akkor is, ha ilyen messzire olvastam, és nem írsz semmilyen kódot, sokat tanulsz a webes alkalmazás felépítéséről a semmiből. Pagadd meg magát a hátán, nagyszerű munkát végez.

Köszönjük, hogy időt fordított a harmadik kiadás webfejlesztési útmutatójának elolvasására. A jövőbeli kiadásokba a dokumentum elején tárgyalt több fontos példát felveszem, és sokkal mélyebben belemerülünk a szoftver és a hardverfejlesztés világába. Maradjon velünk arról, hogy mi várható, és várom, hogy megtanítsam, hogyan kell hihetetlen szoftvert készíteni. Találkozunk a következő kiadásban!