Practical Web Based Deep Learning and Security by Example Third Edition Charlotte Harper July 3, 2024 Updated/Converted June 3, 2025

Foreword:

En foaral kreativiteit doe't se al de lêste krêftige ark hân hawwe om wat nuttich te bouwen sûnder te bouwen, en besoarget jild om te ferleegjen foar dat SOFTE LEIDS WILT SJOCHTSJOCHTJOCHTJOCHT BINNE BINNE BINNE BINNE BINNE BINNE BINNE BINNE BINNE. As jo in pear minuten hawwe om troch dit boek te lêzen en te learen wat ik jo wolle learje, of sels persoanlik mei my prate oer jo doelen en krije wat begelieding ynhy goede rjochting, en binne motivearre om te learen om koade te learen en jo boek thús te skriuwen en in dei ynstelde, krêftich te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om de folgjende te bouwen om te bouwen om te bouwen om te bouwen om te bouwen om it folgjende ynfloed te meitsjen om te bouwen en in webside dat alles is wat jo wolle en foldocht oan jo

Oer my: Ik bin in software ûntwikkelder mei in breed skala oan ûnderfining yn C / C ++, Java, Python, HTML, CSS en JavaScript. Ik bou websides minsken wolle brûke, wolle besykje, en sels ferslaafd wurde om gewoan te brûken om te learen, tiid te meitsjen en te fermoardzjen en it wichtichste, ferkeapje ik software. As jo in idee hawwe om krekt te sjen, hoe't jo in webside woenen en funksjonearje, binne jo my ree om my te stypjen, sadat ik oan jo moetsje, en jo binne ree om de kosten te dekken om in webside te dekkenIk moat ekstreem ryk wêze, slimme, suksesfol, of sels detail rjochte of organisearre om in app te bouwen. De kompjûter fersoarget dy organisaasje foar jo. Jo moatte gewoan troch de proef en flater folgje, fokus ûnderhâlde en hurd wurkje yn wat jo dogge, en jo sille in heul suksesfolle karriêre hawwe yn 'e gehiel fan wat jo hawwe

Jo hawwe der trochgien en tocht dat it nuttich wie, of sels as jo dit gewoan folle lêze, oan jo bin ik in as minded yndividu dat jo wolle sjen dat jo slagje yn alles wat jo dogge. Ik bin in yngenieur mysels, in software ûntwikkelder, en in studint skriuwt dit boeken dy't se har libben maklik moatte meitsje troch te jaan om byinoar te jaan as in grutte puzzel yn in grutte puzier yn in wurkjen, nuttich, grut,Piperaal, gearhingjende, en meidwaan oan dat Sukses kin ride, nettsjinsteande de line fan 'e saken. Foar it grutste part is dit wat ik doch: Ik bou apps om mysels te helpen en oare minsken slagje. Ik bin ek in auteur, hoewol dit myn earste publikaasje is dat ik fan doel is te foltôgjen om myn portfolio tegearre te pleatsen yn in nuttige dokumint, en ik bin ek in artyst. Ik sil dit oan jo tajaan, ik bin soarte fan in frjemde persoan. Ik bin net perfekt, ik haw yn 'e wet fan' e wet rûn om te rinnen, sels liede om hegeskoallen te ferlitten enike mines en docht itselde ding, mar ek better, want as jo kinne betelje om jo toetseboerd te keapjen lykas ik gewoan om jild te meitsjen, jo hawwe de boarnen dy't jo moatte wêze om suksesfol te wêzen yn jo libben. Ik hie allerhanne problemen mei famylje opgroeien, dokters, de media, en de wet, en myn koade reflekteart de striid dy't feminisme en froulike natuer is yn in ferdielde en frustreare wrâld. Dit boek is lykwols wat ikEplyk oer, myn poppe, myn portfolio, en myn libbendich, en myn bestean, dus ik wurdearje jo beskôging as jo de tekst thús nimme en derfoar soargen om fan my te learen. Hâld der rekken mei dat ik net perfekt bin, dit boek sil flaters hawwe, ferzjes, en nije edysjes, en jo sille moatte tinke mei jo logyske harsens lykas jo kinne hawwe om in suksesfolle ûnderfining te hawwen om in suksesfolle te hawwen mei myn skriuwen. Begryp ek, begryp ik dat ik goed bedoel, sels as jo útdagings hawwe by it skriuwen. Tink der oer neiKeapje dit: As jo gewoan in kompjûtersysteem kinne hiere, kinne jo foarstelle yn 'e digitale romte, bewarje, en organisearje dan en jo moatte begripe, jo sille ûnûntkombere swierrichheden hawwe mei de ynformaasje dy't jo opnimme en sels publisearje. Ik fertel dit dit om't ik deselde swierrichheden tsjinkomme. Brûk dit boek op jo eigen risiko, wurkje mei jo mienskip en mienskippen beskikber foar jo om software te bouwen binnen in feilige ynstelling,Nim dingen net om teminsten as jo mislearje of sels slagje op 'e ferkearde manier, en wêrom kin ik jo ferwiderje, wylst ik jo op in wrâldwide skodde is oan in wrâldwide globale skaal fan it netwurk op hokker wy sille wurkje, it ynternet. Jo kinne miskien net heul bekend wêze mei wa't ik mei mar in pear wurden bin, mar ik moedigje jo oanLês op, jo sille my kenne as jo my trochgean te lêzen en te begripen by it bouwen fan jo eigen projekten om jo wurk te foltôgjen. D'r sil gjin húswurk wêze mei dit boek, sa lang as jo professors of leararen jo heulendal net oanmoedigje om josels te bouwen as jo lêze, lykas jo in kapstone-projekt ferskine hoe't jo kinne oanfreegje wat jo hawwe leard. Myn Capstone-projekt is de basis foar it measte fan wat jo sille lêze yn dit boek, lykas itBedriuwen koade fan myn foarige projekten, koade haw ik makke en learde metoade te skriuwen, en in opbrûker dy't jo hawwe holpen, as jo jo freon of famylje kinne sjen mei, op it ynternet, advertearre oan jo, as yn 'e

Bedriuwsôfbylding, lykas de software jo bouwe yn it absolute it bêste ljocht om it meast oantreklik mooglik te wêzen foar jo beammen, de besikers fan jo webside. Yn dit boek sil ik in oantal foarbylden fan software-ûntwerp demonstrearje mei in fokus op it web as platfoarm as feiligens. Wy sille de learûnderfining inisjearje troch in basisprojekt te bouwen mei de UNIX-shell, mei backup- en skriptsfunksjes. Dan, wy sille in basis blog-webside ûndersykje, upgrade ús blog mei foto en fideoS, lykas ek dizze funksjes brûke om befeiligingsoplossingen te brûken mei fergese software, en ús server befeiligje mei in plukt ferifikaasjemodule (PAM). Wy sille dan Bestân ôfhanneling kontrolearje en ferwurkjen, fideo-bewurkjen ferkenne, Voice Donaasje, Barcode Scanning en optyske karakter erkenning, ûnder oare konsepten. Undersyks de wei sille wy APIS ûndersykje dy't ús sil helpe om ús software nuttiger en feilich te meitsjen, mei fergees en betelle opsjes. Lâns de wei, sille wy fysike feiligens ferkenne enMilitante ark lykas fjoerwapens en munysje en produsearje ynklusyf barrel en repeaterûntwerp, turrel en drone-ûntwerp, en oare prinsipes sille wy yntegrearje op it besteande netwurk om ús software te beskermjen en sels te demonstrearjen en te bewizen. Wy sille brekke lâns de manier om spultsjes te bouwen, 2D en 3D-rendering-motoren, en wurkje mei ynbêde hardware yn gefal stúdzje foarbylden fan basis dimensjonele software en in elektroanyske vibraasjer respektivelik yn silikonvulij. Underweis, wy sille jo Masine-bruta-oplossingen brûke dy't al te krijen hawwe beskikber om ús software better te befeiligjen. Wy sille ek in stock ark brûke beskikber foar it web om it proses te streamen en te befeiligjen. Dit boek is in hantlieding foar jo sukses yn it bouwen fan in webapplikaasje en yntegrearje it mei in profesjonele netwurk en ynbêde meganyske systemen, en oerbleaune om software en ynbêde hardware te bouwen mei neegrûn kennis as foarige ûnderfining.

Wat dit boek net is: As jo wirklik in webside wolle hawwe, koene jo gewoan in ienfâldige winkel hawwe ynsteld en jo nedich binne, postje in blog, postfoto's of fideo's, of oars as oars sûnder in iennige koade te skriuwen. Dit boek is dat net. Dit boek sil jo leare hoe software te bouwen, is nuttiger, funksjoneel en befeilige as alle software dy't jo al kinne fine, om't it noch altyd prototypes is, kin djoer wêze om te rinnen by in skaal âlderbedriuwenu yn 'e goede rjochting en earm jo mei de ark dy't jo nedich binne en de feardigens en tips dy't jo sille fasilitearje yn it bouwen fan jo en jo oanstriid, klanten, famyljes, befetsje, oannimers, oannimers, oannimers, en de minsken fan it ynternet wolle brûke en

Software in naadloos, automatisearre wyn, hoe't jo Python-koade bouwe om joamyske berjochten te tsjinjen, style saken, yn ynteressyf-oanmelding, ID scannen, ID scannen, ID scannen, ID scannen om jo software feilich te hâlden om jo software feilich, betellingsferwurking, kryptokurency hannel,hrronous taken, en mear. Jo sille leare hoe't jo jo eigen Bluetooth-apparaten kinne bouwe, mei batterijen, CHARERS, MICROCONTROLLERS, MOTORS, Motors en sensoren, mei solder en 3D printe as cast materialen. Ik sil beynfloede fan 3d-ûntwerp oanfreegje op tafoegings en ark en it meitsjen, sadat jo kinne produsearje jo eigen ynbêde, hardware-apparaten mei yntegreare batterijen, opliedings, elektroanyske sirkwers, en funksjonele útgongen. en netwurk se mei Bluetooth eneweb. Spesifyk sille wy twa gefallen ûndersykje, in vibrearjende massager en in selsmakke fjoerwapen, sawol programmearre yn OpenSCAD, dat is beskikber as in grafyske yntervace of kommando-nuttigens en kin yntegreare wurde yn in web foar rappe resultaten. Jo sille leare hoe't jo in webside fan 'e grûn op te bouwen en yndiele fan gjin foarôfgeande ûnderfining, meitsje it funksjoneel, feilich, prachtich, nuttich en it wichtichste praktysk. Jo sille leare hoe't jo masine learen brûke en komputerfisy brûke om in te meitsjenrning, dy't de grutte trije komponinten sille helpe om nuttige software te bouwen troch de juste brûkers te dwaan en de ferkearde te dwaan op in manier dy't realistysk is, praktysk, praktysk, en meidwaan oan automatyske, en beskôgjend. Dit boek leart UNIX, spesifyk Debian (Ubuntu), Bash Shell, Python, HTML, CSS, JavaScrOript foar Python lykas oanfragen, lykas nuttich bash-software lykas Git en FFMPEG. Ik sil jo ek leare hoeOm automatysk te hanneljen, en nim betellingen yn kryptokaarskip of út normale debitkaarten, wylst jo besikers in oandiel betelje as jo derfoar kinne dwaan. Ik sil jo leare hoe't ik jild kin meitsje fan jo webside, hoe jo jo app reaksje foar sykmasjines meitsje en har rang meitsje, nei wat jo klanten sille fine om jo te finen, en ranglist yn safolle mooglik sykjen. Ik sil jo leare hoe't jo jo ferkeapjeFtware, advertearje it, berop op kliïnten op syk nei jo tsjinsten, en meitsje in namme foar josels op it ynternet fia avenues dy't al besteane, binne goed, en wurkje goed. Ik sil jo leare hoe't ik jo gegevens op wolk-kompjûters te rêden dy't foar jo wurkje en jo gegevens wolle bewarje en wat jo wolle bewarje en bouwe om jo tillefoan te setten op har tillefoan mei notifikaasjes, e-post, tekstberjochten, tillefoanD MOREVEN OANS OM JOU BINNE BINNE BINNE BINNE TERJOCHT TERJOCHT BYGEN TIL JOU BINNE YOUR BINNE BINNE BINNE DE KLIK FAN E KNOP BEBEID BEBEID OP JO BEFALLEN. Dit boek sil rjochtsje op 'e praktyk fan publisearjen fan media yn grutte hoemannichten, út tekst nei de fideo's nei Audio (jo kliïnt), en jo allinich te meitsjen, en jo, jo software en jo bedriuw sjogge ynBêste manier mooglik. Jo sille ek in pear tips leare en trúkjes fan my, fan kodearen, praktysk plak en fotografy foar jo te ferdielen as jo yn 't alde mooglik hawwe om jo software te bringen om te bringen sûnder mear ynspanning te bringen, wurkje, wurk, of jild dan nedich is. Dit boek hjitPraktyske web basearre djip lear en befeiliging "om in reden te meitsjen: it behannelt it learen fan dizze tekst, de foarbylden oan 'e posysje dy't ik nei it web sil rinne, dat jo kompjûterfisy sille behannelje, gesichtsfisy, gesichtsfisy, gesichtsberken, gesicht moderering, ôfbyldingT, resolúsje-ferbettering, ôfbyldingstiteling, en oare taken lykas foarsizzing, lykas foarsizzing jûn út ôfbyldings, lykas de aard fan 'e ôfbylding as in optysk eksimplaar (in foto fan in ôfbylding, as printe foto). Masine learen is heul wichtich as it giet om webcefeiligens en softwarefeiligens, om't it taken kin preformen dy't oars ûnmooglik wiene. Jo kompjûter kin jo oanmelde mei in passcode, mar it kin feiliger wêze om it te brûken as it jo logt mei joOu kin dit feilige, in kompjûter meitsje dy't jo normaal soe freegje, dat jo in befêstigings- en in nije ip-adres moatte bouwe, maklik om te brûken, yn prinsipe te brûken, yn prinsipe te brûken, yn prinsipe te brûken, yn prinsipe te brûken, yn prinsipe te brûken, yn prinsipe te brûken, yn prinsipe te brûken, yn prinsipe en krêftige software, kin dit genôch wêze. Bying jo software te nau oan 'e software fan immen oars, lykas in e-post tsjinst of tekstberjochttsjinst, is net genôch om jo software feilich te meitsjen, as immen (elke side dy't jo brûke). Elkenieno Bouw software dat ûnfeilich feilich is, hat wat sin fan wat dizze ympliseart. Software is inherent ûnfeilich om't de apparaten en akkounts dy't wy hawwe om tagong te krijen ta ús beskikking, se koene yn 'e hannen wêze fan' e software en kin dêrom in risiko foarmje foar de software sels. Dit is wat fan 'e fokus fan dit boek. In netwurke kompjûter is standert befeilige mei in lange kaai token, neamd en SSH of feilige shell-toets, en wurdt oars it bêste befeiligeIth in webserver, om't de webserver de iepen tagong leveret, lykas steat as steat fan 'e keunstfeiligensynstruminten op' e server dy't himsels rint. De webserver hat tagong ta de webbrowser fan 'e brûker, dy't it machtichste diel fan' e apparaat is foar it apparaat fan 'e brûker, om't it it plak is wêr't de brûker tagong hat ta netwurksoftware. Dizze toolk kin tekst renderje, de websiden dy't jo sjogge, en kinne ek ôfbyldings, audio en fideo opnimme (lykas in foto fan in gesicht of in steat-ID), kin lêze en skriuwe nei Bluetooth-radioEvices, en kin lêze en skriuwe nei yn 'e buert fan fjild, goedkeape kaaikaarten, foks, ringen en sels chip-ymplisearders dy't kinne wurde lêzen en skreaun mei gegevens op it generearre en oanjûn troch in webserved. Mei help fan alle ark ta jo beskikking, mei dit boek sille jo josels útstelle om in befeilige webside te bouwen, en in feilige netwurken kompjûtersysteem dat foar jo wurket, en sjocht en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt en fielt him

ken my, jo wite dit boek, en jo binne ree om te begjinnen. Om te begjinnen, pak in kompjûter (sels de goedkeapste laptop út in doaze winkel, Amazon, as in âlde buroblêd wurket en set it op op in manier dy't wurket

How to read this book: Text highlighted, denotes that the text belongs in a command prompt, where you will write the code you run. The command prompt is heavily keyboard focused and requires little to no clicking, speeding up your workflow and making things easier on you.

Getting started: Let's dive in. We'll start by building code on a local machine and begin without building a website connected to the internet. This is safer to start with, costs nothing, and is easy for you. Depending on your operating system, getting into a bash shell will be a little bit different. For Mac OS, I recommend installing a virtual machine at this point, as you will get the most compatibility with a virtual machine. Various providers such as VirtualBox and Paralells can run a virtual machine for you, though it is also possible to install Ubuntu directly on the machine, if you prefer to use a native environment which is recommended in order to create a fast, streamlined experience. If you are using Linux or Windows, which I recommend, it should be quite easy to create a project. Open your terminal, adjust the sizing as you see fit, and begin following step 2. If you are using Windows, please follow step 1.

Step 1: - Windows users only In Windows, open command prompt as administrator and type wsl –install

Step 2: - Continue here, or skip step 1 to here if you aren't using Windows In an open terminal, (depending on your OS, called Ubuntu in Windows, Terminal in Mac or Linux, or a similar name), begin by creating a project. We do this with the mkdir command, which creates a directory. If you need to create a directory to store your project, which is recommended, use the cd command to change to the directory and and

cd /path/to/directory - The path is the folders (files) that precede your destination directory, your default path is ~ or /home/username (where username is your username). To change to the default directory, type cd or cd ~ mkdir example - Replace "example" with the name of the directory

No hawwe jo in wurkmap foar jo projekt. As it sa wichtich is om dizze map te rêden yn gefal jo moatte wikselje nei in oare masine of ynsette, dat it ree is, wy sille in skript bouwe om jo map te bouwen yn 'e folgjende pear stappen. Mar it bouwen fan in skript nimt in bytsje koade, en koade moat wurde automatisearre om sa nuttich mooglik te wêzen. Dat litte wy in skript bouwe om skripts earst te bouwen. Litte wy begjinne troch it skrift te meitsjen en it útfieren te meitsjen.Wy sille Sudo brûke, Chmod, en oanreitsje hjirfoar, en skilje it skript

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

Now we have created the script, made it executable, and are ready to edit it. nano is a text editor that will let you edit text without clicking, which is much easier than using a graphical user interface. To edit a file with nano, use nano and then the path to the file. To make a script that makes a script, it's fairly similar to making our script in the first place. We'll use the same code as above, replacing the name of the script, "ascript" with an argument parameter, $1. This lets us call the script by typing simply sudo ascript newscript, at which point we can create any new script by replacing "newscript" with the name of your script. The code in nano should look like:

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

And to close nano, we can hold down the Control key and press X, then Y to denote we are saving the file, and hit return. Now instead of typing these three commands to edit a script, we will be able to type sudo ascript ascript to edit the script again. This works! And any new script can be run easily by calling it in the shell. Let's save our work now: Let's write a backup script to save our new script and then back it up in our project directory, while also backing up the backup script.

sudo ascript backup

Now, in nano:

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

Where /path/to/directory is the path to the project you created with mkdir. Later on we will learn how to copy repeat paths like this with a loop and a list, which is less code, but for now let's keep it simple and have a few lines. To run this script and backup your code, save the file in nano with Control+X, Y and RETURN, and type the below into your shell

backup

If you are prompted at all for a password while reading this book and following along in the shell, please enter your user password correctly, you will have three tries before you need to re-run the command. You can use the up and down arrows to rerun commands and edit them, should you need to run anything twice. Simple press up and down intermittently to select a command, before editing the command with the right, left arrows and delete key as well as keyboard, and running it with return.

Lokwinsken! Jo slagge in bjusterbaarlik werom te meitsjen dat jo twa wichtige shell-skripts ferskynt yn jo wurkmap. Wy meie letter letter oer ferpleatse as it projekt grutter wurdt, mar dit wurket foar no. Litte wy trochgean nei backing yn 'e wolk, sille wy dit brûke, sille wy ferskate oare git-oplossingen foar reservekopy hawwe.) BINNE EIN BINNE BINNE BINNE WURKT OP JOU SOFTWARE WILT DY SIN AAN EIN SERVER MAKT OP EIN SERVER, WANNEER EXSkeakelje jo om hiele kopyen fan jo software efter in wachtwurd of kaai te downloaden. It is ynstrumintaal by it opslaan fan jo software, fral as wy migrearje om linux-gefallen te befeiligjen, as jo inkelde koade net ferdwûn wurde, wylst jo gjin kâns is om it automatysk op te krijen, dat wy sille

Oantal Linux-pakketten om dit te dwaan. As jo noch OS wolle brûke, binne jo wolkom om te sykjen om te sykjen en ynstallearje de nedige pakketten online, mar d'r kinne net alternativen wêze foar elk pakket dat dit boek of searje sil

Litte wy in pear kommando's tafoegje om ús wurk te pleegjen mei it reservekopy-skript troch it kommando-sudo-ascript-reservekopy te rinnen.

#  …

Noch ien kear, kontrolearje X om te bewarjen.

Now we need to do some one time configuration for this project. Because it soon will be a Git project, we don't need to type every command every time we deploy from a Git repository, but we'll get the hang of this when we write our deployment scripts. To start, let's make sure we are in the right directory and initialize the git repository and generate ssh keys.

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

Neidat wy SSH-keygen ynfiere, moat de nije kaai wurde opslein yn 'e thúsmap ûnder in map neamd .SSh. It hjit ID_RSA.PUB. Litte wy dizze kaai fine en it kopiearje. It te sjen,

cd ~
cat .ssh/id_rsa.pub

har dokumintaasje te lêzen. Jou jo reposysje foar nije repositêr, jou jo repositêr en beslute as jo it wolle publisearje, en soargje derfoar dat jo gjin bestannen konfigurearje foar ynklúzje. Sadree't de repository is makke, kopiearje de kloon mei SSH URL, en plakke it yn 'e folgjende

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

No kinne jo weromgean nei jo repository mei CD, jo sille hjir bekend wêze. Besykje jo reservekspript no mei reservekopy

Great! Now we can really get coding. Let's install Django now that we have a good grasp on bash and Git. Django will let us automatically back up our software, bash can do this too but Django should have a simpler safer implementation (it can be disabled and configured more easily).

Om software yn Ubuntu te ynstallearjen, sille wy it sudo-kommando brûke. Litte wy de software op bywurkje en upgrade wy al. Dit kin dien wurde mei sudo apt-krij update en sudo apt-getgrade -y -y. NEX, litte wy Python en ús firtuele omjouwing ynstallearje, it hûs fan ús koade, mei it folgjende kommando: Sudo Apt-Get-ynstallearje Python-is-Python3 Python3-Venv

This is all you need to get going with Django in terms of software installs in the Ubuntu instance. For Windows and Linux this should be fairly straightforward, but for Mac you may want to install a virtual machine and Linux on it using a free or paid virtual environment like VirtualBox or Paralells Desktop and recreate the steps above in order to setup an Ubuntu environment. Ubuntu is critical in this case because it is the software the websites run and it enables them to host websites with all of the aforementioned software.

Litte wy graven yn 'e django.

Yn ús map wer, mei CD:

python -m venv venv #  Creates the virtual environment where code is stored
source venv/bin/activate #  Activates the virtual enviroment
django-admin startproject mysite . #  Where mysite is the project I am starting in my current directory.

Django is just getting us started, because Django is hosting the web server and is doing everything we need to get a basic local website up and running. Now that we have Django installed, let's edit the settings a bit to make it work how we need. First, let's create a new app

python manage.py startapp feed

You'll notice the first app is called feed. The app should be called whatever you like, and we will create new apps, but the name of each app must be consistent each time the app is referenced in the code. To add a new app, we will always edit the settings.py in the other directory the app created, named in startproject, hereafter app. Using nano,

nano app/settings.py

Yn 'e ynstellings, fine ynstalleare_apps en skiede de [] yn 3 rigels. Mei help fan fjouwer spaasjes op 'e lege sintrum-rigel, foegje' feed 'ta, as de namme fan jo app. Dizze seksje fan 'e ynstellings.PY soe moatte útsjen:

INSTALLED_APPS = [
    'feed',
]

Foardat wy ferjitte, litte wy testje dat Django wurket. Mei help fan it kommando-Python Manage.Py Runserver 0.0.0.0:8000, wy kinne rinne en nei de lokaasje nei http: // nei in foarbyld: 80 Slach op 'e server mei kontrôle mei kontrôle c, itselde as elk oar kommando.

Now, let's dig into writing some python code. Django has three main components, all of them run by code entirely. The components are called Model, View and Template, and each is at a higher and lower level respectively before the webpage is delivered to the user.

The model is the code that stores information in the database for retrieval, sortation and rendering.

De werjefte beslút hoe't it model wurdt levere, manipulearre, en wizige, hast elke werjefte direkt in model brûkt.

It sjabloan is de HTML-koade mei wat ekstra klokken en fluiten neamd sjabloanaal. It sjabloan wurdt levere troch it werjefte wêr't it is fol mei Python-koade en kontekst lykas modellen en ynformaasje (usuall snaren en heule getallen) fan it werjefte.

Django has other components too, including but not limited to:

Settings, which configures the app as we discussed.

URLs, which are patterns that the user follows to gain access to specific parts of the web application.

Forms, which define how information that is sent to the server is handled and rendered to the database as well as to the user. These are the foundation of processing information on the server side, and can accept any type of information the computer stores, most notably text strings, numbers, and True/False booleans (usually checkboxes).

Sjabloanen, dy't HTML-koade en sjabloan Taal HTML en Brêge binne tusken Python en HTML, wat immen kin wurde tawiisd oan it wurk en nuttich foar in ferskaat oan in ferskaat oan in ôfsettings foar in ôfsettings foar in ôfstimmende apparaat.

Static files, which are usually JavaScript and it's libraries which the server serves and are linked in with the template.

Media bestannen, dy't de server tsjinnet of ekstern hosted, of binne krekt skreaun oan 'e server foardat jo wurde ferwurke en pleatst nei in oare server (in bak) foar hosting.

Middleware, dat is stikken koade dy't tagelyk binne rinne as elke werjefte en wurde beskôge "ynbegrepen" yn 'e werjefte.

Context processors, which process the context of each view and are used to add extra context.

Tests, which validate that the user or request passes certain requirements before the view is rendered.

Konsuminten, dy't diktee hoe websocken omgean en reagearje op kommunikaasje.

Admin, which is used to register models so they can be manipulated in detail within the Django Admin page, where the database can be administered through a graphical interface.

Selderij, dy't asynchrone taken dielen definieart fan 'e django-koade kinne begjinne te rinnen foardat jo fuortendaliks trochgean nei de folgjende taak of line fan koade.

Django kin in protte oare komponinten hawwe, dy't wy hjir yn detail sille besprekke. D'r binne in soad manieren om Django mear funksjoneel te meitsjen, te foegjen, dy't rappe tafoegje, steamende taken, en in mannichte fan software útwreiding om django te ferlingjen, foaral yn 'e werjefte fan' e koade wurdt útfierd. Besjochfunksjes binne kaai, om't se normaal elk stikje koade ferklearje dat spesifyk is foar in spesifyk URL-patroan,

First, let's explore view functions. View functions begin with imports denoting code that will be used in the view, and are defined using regular function definitions or classes. The simplest views are defined by the function definition def, and return an HttpResponse with a basic template. Let's start by defining a basic view to return the text "hello world". Remember that each time you add code after a statement like def, if, while, for, etc, you will need to add 4 spaces for each of the preceeding definitions you would like to apply to your function. We will get into what each of these means soon.

Fanút de map fan ús side, bewurkje de feed / werjefte.py-bestân mei nano en foegje de folgjende rigels ta oan it ein fan it bestân ta.

from django.http import HttpResponse

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

Django's HTTPresponse reageart mei in tekststring, oanjûn mei de iepening en sluten '. Elke kear as jo ynformaasje trochjaan oan in funksje as klasse, lykas fersyk as in tekenrige, moatte jo parenthesis brûke (, iepening en sluten).

This isn't all we need to see our view yet. Of course, we haven't told the server where the view is exactly, we still need to define a path by which the view should render. Let's start by defining a basic path in app/urls.py, and we will get into path groups later.

Yn App / URL.PY, Foegje in line ta nei de ymportferplichting nei it begjin fan it beëinigjen fan it útsicht dat wy krekt binne makke.

from feed import views as feed_views

OMMA, om't dit elk skiedt. Elk artikel moat ek op in nije rigel gean, wer mei fjouwer spaasjes foardat it, krekt as de app yn ynstellings. Leauwe. Wy sille de earste komponint fan it sicht definiearje mei in lege tekenrige-funksje, om in werjefte te meitsjen dat rint op 'e haadtier fan' e websering. Jo urls.Py moat no der útsjen

from feed import views as feed_views

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

Dit is de basis foar it meitsjen fan in webside mei Django dat is folslein statysk is. Om in mear dynamyske webside te meitsjen wêr't wy kinne begjinne mei Caching-ynformaasje, lykas ôfbyldings, fideo's, Audio en mear moatte wy modellen moatte brûke, dy't wy folgjende sille ferkenne. Litte wy no ús koade kontrolearje en de server útfiere. Om de koade te kontrolearjen foar flaters, rinne:

python manage.py check

If there are any error messages, you should carefully review the changes you made to your app and see if there is anything that needs to be fixed, like an extraneous or lacking space, an extra character, an unclosed string, any typo, any accidentally deleted character, or anything else. Reading through the error message (if you have one), you should be able to see the path to a file you created or edited along with a line number, so look into that file and line and see if you can fix anything that is there. If you have fixed the issue, run the above command again. When your software is ready to run and is working, you will see the output "System check identified no issues." Now you're ready to go. Run the server with:

python manage.py runserver 0.0.0.0:8000

Featured, fleksibel en feilich mei JavaScript en masine

hat in tekstfjild nedich om wat ynformaasje te bewarjen. Letter kinne wy in tiidstempel tafoegje, Bestannen, Booleans (wier as falske definysjes dy't kinne helpe om it te dwaan oer wat te dwaan, en kin in eksimplaar om it model te tinken oan in brûker oanmeld by de server, en mear. Litte wy de koade útpakke

from django.db import models # De ymport dat wurdt brûkt om ús klasse te definiearjen en it attributen te definiearjen
class Post(models.Model): #  The definition of our class itself
    id = models.AutoField(primary_key=True) # It id fan ús model, in automatysk generearre kaai dy't ús it model kin litte, hâld it unyk, en is handich as wy moatte ynteraksje mei it model ienris is oanmakke.
    text = models.TextField(default='') # It attribút dat ús klasse winkels, yn dit gefal, wat tekst, standert op in lege tekenrige.

Slút en bewarje it bestân lykas wy earder dienen om te foltôgjen.

There are many other fields and options we will explore when we update this class as our app evolves, but this is the basic necessities of creating an app to post some text. However, this model won't work alone. As described before, we will need a custom view and custom URL pattern to make this model work, and we will also need a form along with a template. Let's explore the form first.

Om in formulier te definiearjen, bewurkje app / forms.py mei nano en foegje de folgjende rigels ta. Wy sille twa ymporten nedich hawwe, lykas it model, lykas it model dat wy hawwe oanmakke (feed.mods.post), en in fjild tegearre mei in subklasse neamd Meta dat it model ynteraktyf sil definiearje. It formulier kin ek in initialisaasjefunksje hawwe dy't it opmakket basearre op ynformaasje op it fersyk, model of oars sille wy dit letter ferkenne.

Model forms are so useful because they can create a model or also edit a model, so we will use them for both. Let's define one in forms.py below.

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',)

Dit is de basis fan wat in formulier en model sjocht. Dit modelformulier kin brûkt wurde om in post te driuwen of te bewurkjen, de tekst te feroarjen of te feroarjen dat it befettet. Wy sille sjen nei yntegraasje fan dit formulier yn in besjen folgjende. Litte wy earst de migraasjes meitsje en de database migrearje, sadat ús koade kin ynteraksje mei it model as it rint. Om dit te dwaan, rinne de folgjende kommando's:

python manage.py makemigrations
python manage.py migrate

Dit sil in minút nimme om út te fieren, mar ienris docht it, lit it jo tagong tastean tagong te krijen ta it model yn 'e werjeften, middenware, of oeral oars yn' e software. Litte wy trochgean troch te meitsjen wêr't wy ús model kinne sjen. Bewurkje feed / werjefte.py en foegje de folgjende koade ta, lykas opmurken. Jo sille neat moatte tafoegje nei it # -teken, dat koade opmerkings is dy't wurde brûkt om ynformaasje oer de koade te jaan oer de koade. Wy sille begjinne troch it ymportearjen fan ús model yn 'e werjeften, en it tafoegje oan in kontekst wêr't wy it kinne jaan yn inSjabloan as in list foar werjaan. Folgjende, wy sille in sjabloan tafoegje wêr't wy it formulier en it model kinne jaan mei in knop om in nij objekt te meitsjen op basis fan it model en post it nei de server. Dit klinkt yngewikkeld, dus litte wy it gewoan efkes stappe nimme. Foardat wy de werjefte foltôgje, litte wy in sjabloan meitsje dy't gewoan it model makket, en soargje derfoar dat wy it kinne sjen troch it meitsjen fan in nije post yn 'e skulp. Hjir is hoe't dat werjefte moat

    posts = Post.objects.all() # Fraach alle berjochten yn 'e database oant no ta

This all looks pretty simple until we get to the bottom. Render, the value returned by the function instead of in a HTTP response like the previous example, always takes a request as its first input, accepts a context (in this case the posts in the database), which can now be rendered in the template, and returns the template defined in the function. The template is going to be an HTML document with a little bit of a language called Jinja2, which renders Python information into the HTML.

To start creating templates, make two directories in feed.

mkdir feed/templates
mkdir feed/templates/feed

Next, edit a template in the directory above, feed/templates/feed, and add the code for this example. Let's look at the template for this example.

Dit is in heul ienfâldige sjabloan. It definieart it iepenjen fan en sluten HTML-tags, in dokuminttype TAG, in leginde titel, in leginde-titel dy't in lytse line tafoeget, en in foar loop dy't elke post tafoeget yn 'e list mei berjochten as in paragraaf yn it sjabloanen. Dit is alles wat it nimt om posten te rinnen, mar d'r binne noch gjin yn 'e database. Litte wy wat oanmeitsje mei de shell. Wy kinne de shell útfiere mei Manage.py

python manage.py shell

Now, let's import our post model

from feed.models import Post

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

As lêste sille wy in URL-patroan moatte tafoegje oan ús feed. Om't ús feed-app sil brûke meardere URL's brûke en wy wolle behâlde maten, litte wy in lokale URL.Py oanmeitsje yn ús feed-app dy't sa útsjocht:

from django.urls import path
from . import views

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

Wy sille de URL.PY moatte bewurkje yn 'e Base-app, wat wy besletten om it te neamen, dit wie de earste map dy't wy hawwe makke. App / app bewurkje / app.py en foegje it folgjende ta oan 'e URL-patroanen

from django.urls import include #  at the top
    # ... previous code here

Now, when we run the server with python manage.py runserver, we will see the page we created because we have the model, view and template as well as URL pattern, along with items in the database. Next, let's implement the form we created and begin creating our own posts. But before we write too much code, let's make a backup using the script we wrote earlier, backup. Run this script in the shell, wait a few moments, and all of the code will be backed up to our git repository.

backup

Implementing the form is relatively simple. We will import our form, add a post request handler to the view, and save the post in the database before redirecting to the same view. We can use the redirect function we already imported, and another function called reverse to get the URL for the view pattern. We will query this with the string 'feed:feed' because the namespace of the included pattern is feed, and the view is also called feed.

    posts = Post.objects.all() #  Query all the posts in the database so far
    if request.method == 'POST': #  Handle the post request

        if form.is_valid(): # Falidearje it formulier


        'form': PostForm(), #  Make sure to pass the form into the context so we can render it.

Now we need to make our app look better, because for now it looks really basic. We can do this by using CSS, either inline, or in classes tied to each object in the document. CSS is really nice because it tells everything on the page how it should look, and can make it look really good. There are a few libraries that can do this, but my personal go to is Bootstrap.

Bootstrap can be downloaded from their website, getbootstrap.com/. Noch ienris, drukke op de knop om de ynstallaasje-dokuminten te lêzen, en de koade kopiearje fan 'e omfetsje fia CDN-seksje. Jo sille dizze koade nedich hawwe oan 'e boppekant fan jo HTML-dokumint, yn in tag neamde holle. Litte wy ek foarút gean en in basisjabloan meitsje, sadat wy dizze keppelings net moatte opnij meitsje yn elk sjabloan.

Meitsje in nije map neamd sjabloanen mei MKDIR-sjabloanen, en bewurkje dan sjabloanen / base.html.

It soe der sa útsjen moatte:

Make sure to copy the CSS and JavaScript, the .css and .js files, because we will need the JavaScript to make our site more functional in the future.

Now, let's return to the bash shell and run a quick command. Remember, if you ever need to access the virtual environment, type source venv/bin/activate. This will let you install python packages locally in a way that lets Django access them. To give our forms generated by Django bootstrap classes, we will use a python package called crispy forms. We can download this with the following command

pip install django-crispy-forms

Once this is installed, add it to the settings.py

    #  … previous code here

No, werom yn ús feedjabloan kinne wy wat dingen ferwiderje. Litte wy it begjin en it ein fan it dokumint ferwiderje en it mei erfskip ferfange fan ús basisjabloan, mei gebrûk fan útwreidingen en de blokdefinysje. Ek sille wy in sjabloan filter tafoegje dy't ymploitearje mei lading en in sjabloanfilter nei it formulier tafoegje. As lêste, litte wy in bootstrap-klasse tafoegje oan 'e knop op' e foarm om it mear te meitsjen as in knop. Dat soe der sa útsjen moatte:

lykas nedich, mar no litte wy ús feroverje my mear feilich te meitsjen, om te melden by in brûkersnamme en úteinlik wichtige ynformaasje dy't jo app feilich en jo eigen akkount tagonklik sil hâlde

Render de sjabloanen en werjeften foar de basis oanmeldpagina. Wy sille ek oare apps meitsje om de bliuwende oanmeldútdagingen te fertsjinwurdigjen om de app te befeiligjen, ynklusyf in Pincode, Rimbady, yn 'e buert fan fjildplanken, eksterne apparaten, eksterne apparaten, eksterne apparaten, multi faktor-ferifikaasje, en fingerprint

Wy hawwe al praat oer it begjinnen fan in app. Fan ús map, binnen de firtuele omjouwing, passage. MANAGE.PY dizze arguminten

python manage.py startapp users

Now, we should have a directory for the new app. Let's start by creating a view in that directory that corresponds to the user login. Django has built in views for user logins, but these won't be suitable for us because we need a custom view, which is preferably done with a definition.

Yn dit werjefte sille wy begjinne troch te kontrolearjen op in postfersyk, pas oan in oanmeldformulier útjûn út Django, ferifiearje it brûkersaccount, en logje yn 'e brûker foardat se oanleiding foardat se trochstjoere.

Yn brûkers / werjefte.Py, foegje de folgjende koade ta

        username = request.POST['username'] #  Get the username and password from the post request
        password = request.POST['password'] #  Authenticate the user

This is all you need for a basic login view. Now, let's create a form for the view by extending the base template. We'll start by creating a new directory for templates in the users folder.

mkdir users/templates
mkdir users/templates/users

Now, we should be able to edit users/templates/users/login.html. While we're at it, we'll create a template to allow the user to sign up too.

nano users/templates/users/login.html

Now, in the template,

This is the basics of a login template. It's really just like the other template in structure, but it looks a little bit different when it's rendered. We can copy this code to build another very similar template called register.html, where we will change the wording and use a new form we build. Let's make the template first. Edit users/templates/users/register.html and add the following code:

Litte wy no in formulier bouwe foar ús brûkersregistraasje en sirkel werom nei de werjeften foardat wy ús brûkerslogins opwurdearje mei in model. Wy sille dit formulier meitsje om mei te begjinnen, mar omfetsje mear details en befeiligingsfunksjes lykas ôfspraken en CAPTCHA yn 'e takomst. Bewurkje de formulieren mei Nan-brûkers / forms.py, en foegje de folgjende koade ta.

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']

sil dat brûke as de basis foar de klasse (trochjûn yn 'e

Folgjende ûndersykje wy it werjefte om in brûker te registrearjen, no't wy in formulier en in sjabloan hawwe. Dit is in modelformulier, krekt as dejinge yn 'e nije post werjefte. Bewurkje brûkers / werjefte.Py en foegje de folgjende koade ta:

#  … imports

This is all we need to get a user registered, but we should have more information. We want to know the time the user registered, what time they were last on the site, some information about them, like a biography, timezone, etc. Also, we will need to update our feed model, Post, to account for the User model and attribute posts to each user. In order to do that, we will update the models.py in both apps. Let's start by editing the feed model. It should look like this now:

from django.db import models #  … imports
    author = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True, related_name='posts') # Foegje dizze rigel ta

Op berjochten hawwe wy al makke, en in besibbe namme, dy't wy kinne brûke om te ferwizen nei de postobjekten dy't de brûker makket. Dizze relatearre namme, oars as post.Author, de auteur fan 'e post, jout Amerikaanske brûker dy't de post sels pleatste. Wy kinne no de berjochten in brûker krije troch it útfieren fan brûkers. Stosts.all (), of

Now, let's make our logins more resilient. We can already make our site much less vulnerable to phishing by simply rate limiting the number of times we will permit a login to the site, this is quite easy. Let's also begin to store some information about each user before as we continue to develop our app. Editing users/models.py, add the following code.

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='')

Note that this model is fairly similar to the Post model. We have an additional import, timezone, which will allow us to set defaults on the datetime fields, and we also have a CharacterFeild and TextField like the post. Using all of these timestamps helps us secure the site and understand its use, and the text fields let us render information about each user, or author, on the website. The OneToOneField should be the only minor consideration, it behaves exactly the same as a ForeginKey but with only one per subsequent model. This way, the user only has one profile, while they may have many posts.

Litte wy ús oanmelding ferbetterje en opsicht sykje nei akkount foar it profyl. Bewurkje earst brûkers / werjefte.Py en fokusje op it register werjefte:

#  … imports
            Profile.objects.create(user=user) #  Make sure to add this line, to create a profile for the user

Dit soarget gewoan in profyl foar de brûker, sûnder ien fan 'e ynformaasje yn te foljen. No, wy wolle derfoar soargje dat it brûkersaccount net te faak kin wurde oanmeld, of teminsten kinne wachtwurden net te faak wurde besocht, dus litte wy de oanmeld werjefte bywurkje.

#  … imports
        if user and user.profile.can_login < timezone.now(): #  Note that we now check if the user can log in
        else: #  If the login wasn't successful,
            user = User.objects.filter(username=username).first() #  This is the part where we update the users profile 
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) #  So they can't log in again for a few seconds

selde brûkersnamme. Dizze manier, in kwea-aardige brûker sil net sa gau sa gau in wachtwurd kinne riede. It oantal sekonden yn 'e DateTime.Himedelta () kin ek bywurke wurde, en de webside sil mear resilient noch in bytsje minder brûkber wêze mei mear sekonden. Ik riede 15 oan om te begjinnen

Tink derom, wy bouden in backup-skript om ús wurk te rêden, dus litte wy foarút gean en werom hawwe wat wy oant no ta hawwe om te soargjen dat wy alles hawwe opslein. Rinne it kommando:

sudo backup

Once again, this will save your work so far. I recommend running frequent backups to save your work, and you might even want to run a backup job automatically. You can do this using a UNIX utility called cron. To activate this utility, run the following command and enter your password:

sudo crontab -e

As jo noch net al hawwe selektearje foar Nan, dan moatte de tekstbewurker jo al bekend wêze, en rôlje nei de ûnderkant fan it bestân mei de pylktoetsen. Foegje de folgjende rigel ta:

0 * * * * sudo backup

Cron uses the format minute, hour, day of month, month, day of week, where a * or a number represents when to run the command. Using a 0 for the minute and * for the rest of the options, we can run a command on the first minute of every hour at the start of the minute. This lets us back up the code automatically. All of cron's jobs when executed with sudo run as root, so we won't need to type in a password every hour.

To make it easier to back up our code without using a password, let's disable the password for our backup command. We will do this by executing the following command and entering a password:

sudo visudo

Now, let's scroll to the bottom of the file and add another line:

ALL ALL=NOPASSWD: /bin/backup

Dit lit ús it kommando "Backup" útfiere as elke brûker, sûnder in wachtwurd. It formaat foar dit is maklik, foarheakket de line krekt mei "All Alles = Nopasswd: / Bin /" en einigje mei it kommando, bygelyks, bygelyks / back-up, dy't bestiet yn / usr / bak /.

Now, let's start working with email. Email is really important for websites, because it's a way to keep a website more secure, verify users are real people, and even market products or services to customers. Many people who frequent the internet check their email daily, and receive all sorts of marketing email about products and services they are interested in. There are a few options when it comes to enabling email on a Django website, and you're welcome to pick whichever works best for you.

Earst kinne jo betelje foar in e-posttsjinst dy't jo kinne ynskeakelje om e-post fan jo domein te stjoeren en minimale koade te stjoeren. D'r binne in protte tsjinsten dy't dit oanbiede, lykas Google Workspace, SendinBlue, Mailgun, en mear.

Oars binne jo goed ôf mei it bouwen fan jo eigen e-posttsjinst binnen jo server fanôf it begjin. Ik riede dizze opsje oan, ek al is it mear koade en kin spesjale hosting fereaskje. Jo sille miskien gjin e-postserver kinne begjinne fan jo thúscomputer, dus litte wy foarút gean en ûndersykje de konfiguraasje en koade om e-post te ferstjoeren foardat wy in server begjinne yn 'e wolk en ús eigen e-postserver binnen meitsje.

First, edit settings.py with the following command:

nano app/settings.py

Where app is the name of the app you created with startapp.

Foegje de folgjende rigels ta:

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)

Make sure to change these when you are ready to deploy your app, we will revisit this later. The EMAIL_ADDRESS setting should be the email you would like to send from, and the password (EMAIL_HOST_PASSWORD) should be set to the password you generate for the server. I load the password in from a config file to keep it out of the code using the following logic, above these lines in settings.py:

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

Then, I have set up a JSON file with the config in /etc/config.json using nano as follows.

To edit the file:

sudo nano /etc/config.json

Add the following lines:

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

Wy sille trochgean mei it bewurkjen fan it konfiguraasjebestân en tafoegje alle wachtwurden en kaaien en wy sille yn 'e app brûke. Litte wy no foar no fluch ûndersykje hoe't jo e-post stjoere mei Python. Litte wy earst in sjabloan meitsje foar in ferifikaasje-e-post kinne wy stjoere nei ús brûkers, en set it yn 'e map fan brûkersjabels. Dizze sjabloan sil wurde skreaun yn HTML.

nano users/templates/users/verification_email.html

This email is fairly simple. It takes a context of a user, the base URL for the site, and a user ID and token which are used to verify the user's email. Make sure to define the base URL in settings.py before we write some Python code to render the template. Go ahead and add the following lines to app/settings.py, near the beginning.

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

BASE_URL = PROTOCOL + '://' + DOMAIN

Eventually, when your site is ready for the internet and you deploy it, you will want to define your domain as the domain name you buy to represent the site. This is the name that you will type in the navbar in order to access your site. For now, you can leave the domain blank or use a placeholder. You will also want to change the SITE_NAME to a name you want to give your site, of your choosing.

Before we send email, let's create a token generator so we can have an account activation token that never expires. We can do this by building and importing an account activation token that looks like the following. Edit the file:

nano users/tokens.py

Foegje de folgjende koade ta:

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()

Dizze basis token-generator genereart in token dy't wy de brûker kinne stjoere yn in URL en de brûker kin brûke om har e-post te kontrolearjen en har akkount te kontrolearjen.

Next, let's see how to send an email. Using nano, edit users/email.py.

nano users/email.py

Sending the verification HTML email will look like this:

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)

This is fairly simple. We import the functions we need to send the email, render the email with templates, and our settings, and then we define the email by the template name and send it to the user using a function. You'll notice we haven't defined the function to send the mail, send_html_email, yet, so let's write this below the code we already added to users/email.py

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()

This is a bit more complex, and we aren't ready to run all of this code yet. Notice we are defining an unsub_link, the link the user can use to unsubscribe from our emails. This is important, because users will need to be able to opt out of our emails unless they want to see them, at any time. We also add a text alternative to our message, which is the HTML message stripped of HTML tags. Lastly, we check if the email sent, and if it didn't, we mark in the user's profile that their email isn't valid.

Let's move back to the user models so we can make this all work. We need to define a function to generate a link to unsubscribe, and define a boolean field to mark that the user's email is not valid.

First, add the following imports to the top of users/models.py

nano users/models.py

#  …

Next, let's add functions to the user model to make the token and check the token used to activate the email, as well as the field to save whether the user is successfully receiving their mail. In users/models.py again, add the following code to the end of the model (indented code)

#  …
            TimestampSigner().unsign(key, max_age=60 * 60 * 24 * 30) #  Valid for 30 days

This is fairly simple, we use a timestampsigner, which is a basic cryptography tool, to create a token which will expire after a certain amount of time, and we also use another function to check if it is valid. We use these tokens twice, once to verify the email, and once for an unsubscribe link.

Now that we have these, the last of the work we will need to do is in the views. Within users/views.py, let's add views to verify the email address, and to unsubscribe.

nano users/views.py

First, add the following imports. I threw in a few extra so we won't have to import more items again later.

from .email import send_verification_email #  Make sure to import the verification email sending function

You may already have some of these imports, but it doesn't hurt to repeat them. You're going to need to import the verification email sending function, as well as account_activation_token from users.tokens, among other imports.

Now, at the bottom of the file, add the following code:

        #  unsubscribe them
    #  Otherwise redirect to login page
#         sendwelcomeemail(request, user)

kin hjir in basisfoarm brûke, en de funksje neame om de e-post foar ferifikaasje te stjoeren. Foardat wy dit dogge, lit ús derfoar soargje dat it yn it earste plak wurdt ferstjoerd, troch it tafoegjen fan in funksje Rop nei it registers werjefte. Foegje dizze line ta krekt foar it trochferwizing yn it registersagen, def registrearje, yn

nano users/views.py

#  … (after) def register(request):
#  … (before) redirect(

You don't need to add the first and last lines in that code snippet, just make sure the register view sends the verification email to the user. It should look like this:

#  … imports
            send_verification_email(user) #  Make sure to add this line!

Now, we'll need to add a form to resend the activation email. In users/forms.py, add the following form:

#  … (imports)

We will also need a template corresponding to this resend email activation form. Let's add this template in. Edit the file:

nano users/templates/users/resend_activation.html

Next, add the following code to the file.

Whew, that's a lot! Now, when we deploy the code to our server, we will be able to send HTML email and activate user accounts with a click in the email. We also might want to send a simple welcome email, so let's see how to do that. Back in users/email.py, add the following code:

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)

Also, we will need a template to render all of this information. On my website, the template looks like the below, but you are welcome to format it however you like.

Note that we don't have closing body or html tags, because we add these in when we add the HTML unsubscribe link. These are important, but we don't want to define them twice.

So what's next? We have come a long way. Really, we should be ready to deploy the site to a server. We can add the @login_required decorator and make our views secure, take user signups, send compliant email, and cache information, which is the basis of what a website needs to do to stay relevant. We'll add a few more useful features, and then build a basis for deploying our code to a remote server, setting up a mail server, domain configuration, and filters to make our site secure and appropriate.

We'll also need a password reset view, so let's add that in really quick. Django's built in password reset view is broken in some functions, but we'll look at how to write our own view, email template, forms, and URL patterns. Here's what the view looks like, in users/views.py

# ... imports

This form is built in to Django, but we'll need a template to confirm the password reset, users/templates/users/password_reset_confirm.html

We also have a template to send a password reset email, with a simple form, in users/templates/users/password_reset.html

It sjabloan foar de e-post sels is it ienfâldich, it is in basis HTML-bestân dy't in keppeling hat om it wachtwurd te resetten, yn brûkers / sjabloanen / brûkers / wachtwurd_reset_Ermail.html. Django sil dit bestân automatysk ynterpretearje.

We'll also need two more templates. The first is to confirm that the email has been sent. Views for these are already in Django, so we just need to address them in the urls.py. This template is located at users/templates/users/password_reset_done.html

En it lêst om te befêstigjen dat it wachtwurd weromsette is foltôge, brûkers / sjabloanen / brûkers / Wachtwurd_reset_complete.html

No, wy hawwe URL-patroanen nedich foar dizze werjeften. Yn brûkers / URLS.PY, foegje de folgjende URL-patroanen ta:

    # ... Previous URLs here

Four templates, that's a lot! But now we can be sure to be able to reset the user's password any time we need to, all from the web browser.

ree om troch te gean, te lêzen, folgjende, wy sille dekke om jo koade te ynsetten en in e-postserver ynstelle, lykas jo automatysk in nij projekt ynstelle kinne mei in pear ienfâldich

Foegje ek in unyk ta, identifisearre identifier oan it brûkersmodel dat sil wurde brûkt om ekstra feiligens ta te foegjen oan ús oanmelding. Bewurkje de brûkersmodellen, brûkers / Model.Py, foegje it folgjende ta

#  Make sure to import the uuid, timestamp signer and URL generator (reverse)
    #  Add this code here
    #  And add this function
            TimestampSigner().unsign(key, max_age=60 * settings.AUTH_VALID_MINUTES) #  Valid for 3 mins

de brûker. Wy sille dizze basis kryptografy brûke om in werjefte fan twa faktorferifikaasje te bouwen. Foardat wy wat oars dogge, litte wy de migraasjes rinne, sadat ús brûkersmodellen wurde bywurke. Yn 'e map mei beheare.PY, Rinne de folgjende kommando's útfiere om de te meitsjen en te foltôgjen

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

This is important because every time we make changes to the models, we will need to create the tables and update the database with defaults before we can actually use the models.

Folgjende, litte wy ús oanmeldjen werbeting jaan om trochferwizing nei in sekundêre ferifikaasje werjefte. Yn brûkers / útsjoch.Py, ferwiderje de oanmeldfunksje en trochferwize nei de URL, wy hawwe krekt generearre yn 'e brûkersmodellen.

#  … imports
        if user and user.profile.can_login < timezone.now(): #  Note that we now check if the user can log in
            #  Remove the auth_login function that was here
                return redirect(user.profile.create_auth_url()) #  Note we redirect to a new URL here
            else: #  If the user isn't using mutli-factor authentication, just log them in.
        else: # As de oanmelding net suksesfol wie,
            user = User.objects.filter(username=username).first() # Dit is it diel wêr't wy it brûkersprofyl bywurkje
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # Sadat se in pear sekonden net opnij kinne oanmelde

Dat dit is aardich ienfâldich, wy hawwe no in manier om te ferwurkjen nei de twa faktor ferifikaasje werjefte as wy it oanmeitsje. Wy hawwe ek in fallback yn gefal dat de brûker gjin tillefoannûmer hat tafoege. Wy sille in basis werjefte tafoegje om gau in telefoannûmer te foegjen en yn te loggen mei in tekstberjocht.

First, we need an easy way to send a text message from our code. To do this, we can choose from a number of APIs, but the easiest one in my opinion is Twilio. They also offer good pricing for smaller projects, as well as bulk discounts. Create an account on Twilio.com, fill in some details about your project, buy a phone number, and copy your API keys to your settings.py. Then, add this code under a new file, users/sms.py.

nano users/sms.py

#  Import all of the necessary packages
#  This code sends the text with twilio
#  A helper function to get a number with so many digits
#  Send the text to verify the user
#  Send a user any text with this function
#  Validate the code with this function
#  Validate the time

Be sure to change your settings appropriately, adding these lines with your keys:

#  Make sure to copy these from your Twilio dashboard
AUTH_VALID_MINUTES = 3 #  The number of minutes the TFA page is active once instantiated

First, we will need forms for our two factor authentication views. Editing users/forms.py, add the following code.

#  … imports
#  A form for entering our phone number
#  A form for authenticating

Folgjende, litte wy de werjeften oanmeitsje yn brûkers / werjefte.Py

# ... Ymport

We will also need templates for both of these views. Let's add the mfa template first.

nano users/templates/users/mfa.html

Add this HTML code to the template

Dit is aardich sels ferklearjend. It formulier stjoert in koade as in lege koade, en jo sille fernimme yn 'e werjefte dy't wy de koade stjoere as wy in lege koade krije. Dan hawwe wy gewoan twa yntsjinjen knoppen, en dizze manier kinne wy de koade stjoere mei beide knop. Folgjende, wy sille in ienfâldige foarm tafoegje om in telefoannûmer ta te foegjen.

nano users/templates/users/mfa_onboarding.html

Foegje de folgjende HTML ta:

Dit formulier is in protte ienfâldiger, it makket gewoan it telefoannûmer dat wy oanmakke en lit de brûker in tillefoannûmer tafoegje.

This looks really good! As long as everything is properly set up, we should be able to send messages, and log the user in with their phone number as soon as we add the URL patterns. The last thing we need to set up is a profile view so we can make sure the user can change their phone number without being logged in. Also, eventually we will want to add a "stop to quit" option, so the user can text "stop" to opt out of future text messages.

Litte wy in profylwurd tafoegje oan 'e brûkers / werjefte.Py. Dizze werjefte sil de bio fan 'e brûker bywurkje, e-post, brûkersnamme, en tillefoannûmer, lykas wy kinne tastean dat wy ús mearfaktor-ferifikaasje kinne ynskeakelje. Earst sille wy noch twa mear formulieren nedich wêze yn brûkers / forms.py

# ... imports

Folgjende kinne wy in werjefte oanmeitsje om beide fan dizze formulieren te brûken. Bewurkje brûkers / werjefte.Py en tafoegje yn 'e werjefte.

#  Add these imports

Wy sille ek in sjabloan nedich hawwe foar dizze werjefte.

nano users/templates/users/profile.html

Jo sille fernimme dat dit in frij ienfâldige foarm is, mar hat wat javascript deryn dy't automatysk de ynhâld fan it formulier pleatst as se wurde bywurke. Dit is handich om te hawwen, dus jo kinne bewurkingen meitsje sûnder om elke kear yn te drukken.

Folgjende, wy hawwe URL's nedich dy't al dizze werjeften fertsjinwurdigje yn 'e URL-patters. Bewurkje brûkers / URL.PY en foegje dizze koade ta:

# ... Foarige koade, ymport
# ... URL-patroanen dy't wy earder ynfierd hawwe, foegje de folgjende trije rigels ta

No is it in goede tiid om ús projekt út te testen. Mar earst litte wy in oare reservekopy útfiere.

backup

En útfiere de server. Foardat wy ynsetten nei in Linux-server, is it in goed idee om twa faktorferifikaasje op it akkount yn te skeakeljen. Wy sille dit dwaan nei ús profyl URL, / brûkers / profyl / en it fakje kontrolearje om ferifikaasje te meitsjen nei it yngean fan ús tillefoannûmer ynskeakelje, en it yntsjinjen fan it formulier yn.

python manage.py runserver localhost:8000

Besykje de webside troch nei jo webbrowser te gean, ik brûk yn dit foarbyld yn dit foarbyld, en de URL https yngean: // LOCALHOST: 8000 / Accounts / profyl /

Jo sille kinne oanmelde as nedich en twa faktorferifikaasje ynskeakelje.

Dit projekt hat in server nedich om op te rinnen, sadat it echt kin stjoere. Mar earst hawwe wy in manier nedich om flaters te sjen. Jo sille merken dat as jo de server útfiere yn debugmodus, mei ynstellings.SN-gelyk oan wier, toant de server automatysk flaters. Om flaters sjen te litten sûnder debugmodus te brûken, dy't ûnfeilich is op in produksjerver, moatte wy dêr in werjefte tafoegje. De wichtichste flaters dy't wy moatte om te behanneljen binne:

Flater 500 - in probleem mei ús koade ERROR 404 - In pagina dy't net fûn waard (brutsen URL) Flater 403 - in tastimming wegere flater

Litte wy in nije app tafoegje om dizze flaters te behanneljen, flaters neamd.

python manage.py startapp errors

Foegje dit ta oan de ynstellings. Lead, om't wy earder dienen, yn 'e ynstalleare_apps-ynstelling, en begjinne troch ferwizing ta te foegjen yn app / URLS.PY, wêr't app de namme is fan jo Django-projekt.

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

Dit is alles wat wy nedich binne neist flater werjeften, sjabloanen en in bytsje middilder. Litte wy dat sa definiearje as sa:

# Meitsje jo werjeften hjir.

NEX lit ús de middels definiearje om dizze flaters te behanneljen. Wy sille dit dwaan troch earst ta te foegjen oan Middleware_Classes yn Ynstellings. Leit, mei de namme fan ús middgeware.

    # ... foarige middollare

Folgjende, litte wy de middeling tafoegje.

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.')

Wy foegje in funksje ta om de hjoeddeistige útsûndering te krijen mei in threading Lokaal te brûken, dy't ús helpt elke flaters yn ús koade te spoaren. Yn termen fan sjabloanen hawwe wy allinich ien nedich, om't wy de titel yn 'e werjefte dynamysk definiearje. It sjabloan moat gewoan de titel en "trace", ús flater Traceback út 'e kontekst.

nano errors/templates/errors/error.html

Dit is ús ienfâldichste sjabloan, mar dat is hoe maklik it is om de flaters yn ús projekt te sjen. NEX lit ús debug útskeakelje yn ynstellings.

nano app/settings.py

Fyn dizze rigel wêr't it is ynsteld op TRUE, en feroarje it nei FALSE

DEBUG = False

Gean foarút en reservekopy de app no. Wy binne ree om te ynsetten nei in Linux-server op ôfstân, en bliuw feiten dêrwei tafoegje.

sudo backup

Foardat wy dizze koade nei in server pleatse, moatte wy beskôgje dat d'r guon problemen kinne wêze mei de koade. Ofhinklik fan it gefal, siden dy't ynformaasje akseptearje, sille problemen hawwe, sille problemen hawwe mei spam wurde pleatst en swierrichheden op it ferwiderjen fan it spam. Dit soe net fuort moatte barre, mar as it bart, sille wy letter-ûndersykje hoe't jo SPAM moatte moderearje op 'e side om tagong te krijen ta de side, mei hoe't jo de brûkersde identiteit hawwe deaktivearje, en ferifiearje de identiteit fan in brûkermei in scan fan har id as in biometrysk scan, lykas in fingerprint as gesicht

Sykje nei it foarbyld fan it multi-faktor dy't wy ûndersochten, yn produksje, yn produksje, kinne dingen oars wêze. Notysje hoe't wy taryf beheine oanmeldingen binne, en tokens ferrinne. As robots tagong hawwe ta in side, kin twa faktorferifikaasje lestiger wêze, om't se tagelyk koade kinne ynfiere, is de brûker. Om dit te bestriden, litte wy in model brûke yn 'e brûkersmodellen, hoe't wy ynteraksje hawwe mei de side as wy ferifiearje mei multi-faktor-ferifikaasje mei in telefoannûmer. Wy sille ek inopsje om mei e-post te ferifikaasje. Begjin troch de brûkersmodellen te bewurkjen mei

nano users/models.py

Dit is wat it model wy tafoegje moatte d'r útsjen. Wy hawwe gjin metoaden nedich, gewoan fariabelen om in ID te bewarjen, de brûker, de brûker, de tiid, lingte en besykje tsjin alle multi faktor-ferifikaasje (in koade lykas 123456 stjoerd nei in tillefoan of e-post).

# In basis token brûkt om oan te melden by de webside

Litte wy ek in privileezje tafoegje oan ús brûker, en wy sille it no foar de hân ynstelle, foardat jo úteinlik migrearje om te registrearjen om privatysk brûkers automatysk te befrijen. By de brûkermodellen, foegje dizze line ta yn it profyl:

    vendor = models.BooleanField(default=False)

Lykas by alle feroarings oan 'e database moatte wy Migrations meitsje en de database meitsje en wy in moederje dat wy in moade.PY-bestân bewurkje yn Django. Tink derom, om dit te dwaan brûke jo earst boarne (as it net is brûkt, om't de terminal net iepen wie) en dan is Python Manage.py om de migraasjes te meitsjen en te migrearjen.

cd project-directory-you-named # (as nedich)

Foar no kinne jo alle akkounts ynskriuwe dy't jo hawwe makke as vendors troch de shell te brûken.

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

Litte wy ús werjefte fan US Multi Factor-ferifikaasje evoluearje om dit token te brûken. Earst moatte wy ús MFA helper-nutsbedriuwen oanpasse. Mei help fan Nano,

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

# Ferifiearje de brûker mei help fan har e-post as telefoannûmer
    token = MFAToken.objects.filter(uid=username, expires__gt=timezone.now() + datetime.timedelta(seconds=30)).order_by('-timestamp').last() # Filterje it token troch de wearde trochjûn yn 'e URL (in 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)) # As dizze sesje net is oanmakke, meitsje it dan oan
    user = User.objects.filter(id=token.user.id).first() # Krij de brûker út it token
    if not user and request.user.is_authenticated: return redirect(reverse('feed:home')) # As se al ferifieare binne, logje se dan oan
    if not user: raise PermissionDenied() # Wegerje as der gjin brûker waard fûn
    if not user.profile.enable_two_factor_authentication and user.is_active and user.profile.check_auth_token(usertoken, token): # Kontrolearje it Auth-token
        auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Log yn 'e brûker as se net al binne oanmeld
        user.profile.mfa_expires = timezone.now() + datetime.timedelta(minutes=settings.LOGIN_VALID_MINUTES) # Stel in ferstriken yn op har multi-faktor-ferifikaasje
        return HttpResponseRedirect(next if next != '' else reverse('landing:landing')) # De brûker trochferhegje nei de folgjende pagina
    if not user.profile.mfa_enabled: # Kontrolearje as MFA ynskeakele is
        if not check_verification_time(user, token): # Kontrolearje de tiid
            user.profile.mfa_enabled = False # Ferwiderje it telefoannûmer
            user.profile.enable_two_factor_authentication = True # MFA ynskeakelje
            user.profile.phone_number = '+1' # Skeakelje it telefoannûmer út
            user.profile.save() # Bewarje it profyl
            auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Log de brûker yn as har MFA net ynskeakele is
    if request.method == 'POST' and not fraud_detect(request, True): # As it fersyk is in postoanfraach
        form = TfaForm(request.POST) # Instantiate it formulier
        code = str(form.data.get('code', None)) # Krij de koade
        if code and code != '' and code != None: # Soargje derfoar dat it net leech is
            token_validated = user.profile.check_auth_token(usertoken) # Kontrolearje it Auth-token
            is_verified = check_verification_code(user, token, code) # Kontrolearje de koade
            if token_validated: # As alles
                if is_verified: # Is yn oarder
                    user.profile.mfa_enabled = True # MFA ynskeakelje (as net al ynskeakele)
                    auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Ynlogge de brûker
                    for key, value in request.GET.items(): # Bou in queryfering foar de folgjende parameter (as ien)
                        return HttpResponseRedirect(next) # Ombribjen
            elif not token_validated: # As it token unjildich wie
            if p.mfa_attempts > 3: # As der te folle besykjen wiene
            if form.data.get('send_email', False): # Stjoer de e-post (as tekst)
    # RENDER DE FORM (FOAR Krij oanfragen)

As wy yn dizze koade tafoegje, soargje derfoar dat jo de funksje hawwe ymportearje om in e-post te stjoeren. Oan 'e boppekant fan it bestân, de brûker werjeften (mei oare ymport), tafoegje

from .mfa import send_verification_email as send_mfa_verification_email

No, wy moatte dy funksje skriuwe foardat jo ien fan dit wurk wurkje. It moat ús Stjoer e-postfunksje útwreidzje, en stjoer gewoan in e-post nei de brûker mei de ferifikaasjekoade.

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))

Dat dit wurket geweldig, no hawwe wy in nijsferifikaasje-systeem dat hinget dat in telefoannûmer ôfhinklik is om oan te melden. Mar wy hawwe ek in manier nedich om te ferwiderjen, of ferbergje jo net mei ús betingsten. Dizze kinne spammers wêze, robots as elkenien dy't net goed betsjuttet foar ús wurk. Sjoch efkes sjen nei in werjefte dy't ik haw foar kontroleart brûkers op myn webside:

# Ymport
from .tests import is_superuser_or_vendor # Wy sille dizze test moatte oanmeitsje
    # Krij list mei brûkers
    return render(request, 'users/users.html', { # Brûk brûkers werom yn in sjabloan

Tink derom dat dizze koade in test brûkt, wy sille dizze test moatte ferklearje yn in testen.py-bestân en ymportearje it. Brûkers bewurkje / testen.py, litte wy de test oanmeitsje.

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

Dit is yn kombinaasje mei de brûkers / brûkers.htmm-sjabloan, dy't sokssawat sjocht,

Tink derom dat it sjabloan in oar sjabloan omfettet, brûkers /user.html. As jo in sjabloan brûke dy't in subtimpt hat en net útwreidingen brûkt, is it in goed idee om in understore te foegjen () Foardat de namme fan it bestân om út te wreidzjen, om sjabloanen te ûnderskieden.

Tink derom dat dit in soad Jinja is, jo hawwe miskien net al dizze fariabelen definieare. Mar dit is wat myn koade der útsjocht.

      <small># {{usopdracht.ID}} </ lyts>

Wy hawwe ek in oare subtimplate nedich, toggle_aktyf.html. Dit sjabloan moat in formulier wêze dat wy kinne wikselje oft in brûker aktyf is.

Wy sille ek moatte tafoegje moatte tafoegje om brûkersaktiviteit te wikseljen, en passende URL-patroanen. Wylst wy deryn binne, litte wy in werjefte tafoegje om in brûker te wiskjen yn it gefal dat wy dat nedich binne.

# Ymport
    success_url = '/' # It trochferwizing op URL fan sukses
    def test_func(self): # Test as brûker superuser is en tastimming hat om te wiskjen

Wylst dit praktysk is as nedich is, soe it de measte fan 'e tiid net nedich wêze moatte, kinne wy gewoan de sichtberens fan brûkers dy't de side besykje as wy moatte ôfwize.

De URL-patroanen dy't wy tafoege sjogge d'r sa út. Mei Nano, bewurkje brûkers / URL.PY en foegje dizze rigels ta:

nano users/urls.py

De rigels moatte yn 'e list mei paden gean yn' e brûker werjeften, foar it ein "]" mar nei it begjin "[" ["[

# ...
# ...

sudo backup

Dus no hawwe wy in pear nuttiger funksjes. Mar wat oer it grutte ôfbylding hjir? Dizze koade is noch net tagonklik fan it ynternet, hawwe wy noch gjin mailserver, en wy moatte útwreidzje om útwreiding om ús te helpen de side te helpen de side te ferkennen, tegearre mei befeilige protokollen foar autentiseare primilegearre brûkers.

Hâld der rekken mei dat de koade no rinne is relatyf dun, it sil moatte wurde ûnderhâlden en ferbettere foardat wy ree binne om te brûken wat wy in produkt moatte bouwe. Soargje derfoar dat jo foarsichtich wêze wat jo dogge mei it ynternet, soargje derfoar as jo dizze side ynleverje op it web op in Linux-server, hawwe jo in plan om net winske ynteraksjes te blokkearjen mei jo webside. Dit sil wierskynlik earst gjin probleem wêze, mar wy sille in ferskaat oan oplossingen besjen om dit te bestriden, ynklusyf masjine learen,keunstmjittige yntelliginsje en kompjûterfisy. As it docht om in probleem te wurden, sjoch dan yn dizze tekst foar in

Yn termen fan it hiere fan in VPS, binne d'r in soad plakken wêr't jo kinne gean. Google Cloud hat VPS-servers, Ionos, Kamatera, Amazon Aws, en mear providers biede wolker Server Solutions biede oan dat sil by ús behoeften passe.

Jo moatte fia har formulieren klikke en in plan selektearje om te begjinnen. Jo kinne mei in basisplan gean mei elke provider, mar soargje derfoar dat de leveransier yn 'e poarte-post-server-server hat om e-post te ferstjoeren (dit moat poarte 587 en poarte wêze), guon blokkearje dizze havens blokkearje. Oant no haw ik de bêste ûnderfining hân mei Ionos en Kamatera, sille beide tastean my unbeheind e-post te stjoeren en har prizen is aardich goedkeap.

You will connect to your new server over a protocol called SSH or secure shell, which allows you to remotely interface with the server exactly like your personal computer, from your personal computer. When you set up the server, the hosting provider is likely going to ask you to add an SSH key, or they will give you a username and password. The SSH key is how you will log in to the server from the command line to edit the code. Use the below ssh-keygen options to generate an ssh key.

ssh-keygen

Save the file and overwrite it if you need to, it's good to rotate your SSH keys if you haven't already. Now, you can use the following command to see your SSH key. You will want to copy it to your remote server so you can use it to authenticate.

cat ~/.ssh/id_rsa.pub

If you weren't able to see an SSH key when typing that command (a long string of digits and letters starting with "ssh-rsa AAA"), try generating an RSA key (they are more secure, so I advise to use them.) The following code will generate a 4096 bit RSA SSH key.

ssh-keygen -t rsa -b 4096

Meitsje in VPS-rinnende Ubuntu, lykwols dat jo dit dogge om dit te dwaan. As jo ienris in VPS hawwe makke troch te klikken troch de foarmen op 'e foarmen op' e oanbiedingen (KAMatera.com of ferlykber), dit wolle oanmelde. Om dit te dwaan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan, brûk dan it SSH-kommando mei jo IP-adres (it adres dat liket op xx.xx.xx). Jo moatte ek gefoelich wêze foar de standert-brûkersnamme op 'e server dy't wy oanmakke, bygelyks Ubuntu.

ssh ubuntu@XX.XX.XX.XX

Jo kinne miskien wurde frege om in wachtwurd, as jo om in wachtwurd wurde frege, yngean it yn. Wy sille de standert brûkersnamme hawwe, dus litte wy begjinne troch in nije brûker te meitsjen en in SSH-toets ta te jaan oan har akkount.

Litte wy begjinne troch in nij SSHD_CONFIG-bestân ta te foegjen, wat fertelt de server hoe't jo SSH brûke moatte.

nano sshd_config

# Dit is it SSHD-server-systeem-brede konfiguraasjebestân.  Sjen
# sshd_config (5) foar mear ynformaasje.
# Dizze SSHD waard gearstald mei paad = / usr / local / sbin: / usr / local / sBin: / usr / bin: / sbin: / by: / usr / spultsjes
# De strategy brûkt foar opsjes yn 'e standert SSHD_CONFIG ferstjoerd mei
# OpenSSH is om opsjes op te jaan mei har standertwearde wêr
# mooglik, mar lit se kommentearre.  Unkommende opsjes oerskriuwe de
# standertwearde.
# Haven 22
# Adresefamily elk
# Harkje 8.0.0.0
# Harketaddress ::
# Hostkey / etc / ssh / ssh_host_rsa_key
# Hostkey / etc / ssh / ssh_host_ecdsa_key
# HOSTKEY / ETC / SSH / ssh_host_ed25519_key
#  Ciphers and keying
# REEYLIMIT Standert net ien
# Ynlogge
# SysLogfacility Auth
# Logleyvel info
# Ferifikaasje:
# Logingracetime 2m
# PERMITROOTLOGIN YNFORMAASJE Wachtwurd
# Strikmodes ja
# Maxauthtries 6
# MaksSessions 10
# Ferwachtsje .sSh / autorisearre_keys2 om standert yn 'e takomst te negearjen.
# Autorisjprinkipalsefile Gjin
# AutoriseareScommand Gjin
# AutoriseareScommanduSer Niemand
# Foar dit om te wurkjen, sille jo ek hoarten nedich hawwe yn / etc / ssh / ssh_ ssh_wone_hosts
# Hostbasedauthentication nr
# Feroarje nei Ja as jo net fertrouwe ~ / .sSh / bekende_hosten foar
# Hostbasedauthentication
# IgnoreusOnYnbekindhosts NO
# Lês de ~ / .Rhosten fan 'e brûker net lêzen en ~ / .shosts bestannen
# Ignorerhosts ja
# Tunneled Clear Tax-wachtwurden útskeakelje, feroarje hjir nei gjin!
# Permermetypasswords nr
# Wizigje nei Ja om wachtwurden yn útdagings-antwurd te aktivearjen (Paswere-problemen mei
# Guon pam-modules en threads)
# Kerberos-opsjes
# KerberosAuthentication No
# KerberosOrlocalPasswd Ja
# Kerberosticketcleanup ja
# Kerberosgetafstoken NO
# Opsjes foar GSSAPI
# GSSAPIAUTHTENTIONATIONAL NO
# GSSAPICLEANUPCREDIVES JA
# GSSAPISTRATECECTECKECK JA
# GSSAPIKeyExchange no
# Stel dit op 'Ja' yn om PAM-ferifikaasje yn te skeakeljen, ferwurking fan akkount,
# en ferwurking fan sesje. As dit ynskeakele is, sil PAM-ferifikaasje sil
# tastien wurde fia de KBDInterACTiveailauhentikaasje en
# Wachtwurdauttentikaasje.  Ofhinklik fan jo PAM-konfiguraasje,
# Pam-ferifikaasje fia KBDInteractiveailauhentication May Bypass
# de ynstelling fan "PERMITROOTOGIN WONTWOWS".
# As jo gewoan wolle dat de Pam-akkount en sesjekontrôles sûnder rinne
# Pam-ferifikaasje, ynskeakelje dizze dan, mar set Wachtwurd ynsteld
# en KbDInteractiveauhentikaasje oan 'Nee'.
# AllowAgentForwarding yes
# TALJECPFORWARDING YES
# GatewayPorts nr
# X11Displayoffset 10
# X11uselocalhost ja
# Permitty Ja
# PrintlastGOD YES
# TCPkeepalive Ja
# Permhermeren net
# Kompresje fertrage
# ClientaliveInterval 0
# Clientalivecountmax 3
# Brûkte nee
# Pidfile /run/sshd.pid
# MaxStartuFS 10: 30: 100
# Permittunnel NO
# Chrootdirectory none
# Ferzjeaddendum Gjin
# Gjin standert Banner PATH
#  Allow client to pass locale environment variables
# Standert oerskriuwe fan gjin subsystemen
# Foarbyld fan oerskriuwen op in per-brûker basis
# Wedstriid brûker Anoncvs
# 	X11Forwarding no
# MAXTCPFORWARDING NO
# Permitty nee
# ForceCommand CVS-server

Unthâld, Ctrl + X en Y om it bestân op te slaan. NEXT litte wy in basisskript skriuwe Called Initialiseare (alles yn 'e standert húsdap fan ús brûker).

nano initialize

Foegje dizze rigels ta oan it bestân, ferfanging with your SSH key you found using cat. (.ssh/id_rsa.pub)

# !/bin/bash

printsje har kaai. Dizze nije brûker sil wêze hoe't wy oanmelde by de

Gean yn in nije terminal, gean foarút en iepenje de server opnij.

ssh team@XX.XX.XX.XX

Jo moatte dizze kear gjin wachtwurd nedich wêze, om't jo in SSH-kaai hawwe. Wy hawwe ek oanmeld oanmelde mei wachtwurd om de side feiliger te hâlden.

Now, this server starts up completely blank with no information on it. Let's start by cloning our project from git so we can download and run it on the remote machine. On the remote server connected over SSH, first print your SSH key:

cat ~/.ssh/id_rsa.pub

Folgjende, plakke dizze kaai yn 'e Git-ynstellingen lykas wy earder dienen om ús Git-repository op te stellen. Wy meie no ús projekt direkt oan 'e server kloeie. Soargje derfoar dat jo earst it projekt lokaal reservek hawwe, dat it is op 'e Git-server om te downloaden.

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

Perfect. Now all of the files are here. We can see them with ls

ls

Litte wy no begjinne mei de server yn te stellen. Bekame earst jo projektidsitaal yn in ienfâldige, memorabele namme dy't wy sille brûke foar it projekt.

cp -r yourproject whatyoucalledit

Wêr "Whatyoucalledit" is de nije namme fan jo projekt. Folgjende sille wy in basisútjefte moatte bouwe om de server yn te stellen. Wy sille dit nut opslaan en it yn 'e takomst brûke. Om dit hulpprogramma te bouwen, litte wy in brûker binêre oanmeitsje om te definiearjen hoe't wy in skript bewurkje. Mei help fan bash, bewurkje / usr / bin / ascript

sudo nano /usr/bin/ascript

Soargje derfoar dat jo dêr sudo brûke, sadat jo tagongsrjochten hawwe om it bestân te bewurkjen. Yn it bestân hawwe, foegje dizze rigels ta:

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

Tink derom dat dit skript in argumint nimt, de skriptnamme, as $ 1. Earst kontroleart it as it bestân it bestiet, of oars makket de earste rigel om it skript ta te meitsjen, bewurket it, en foeget syn namme ta, en foeget ús ta dy't ús de nammen fan 'e skripten sille bewarje, wy meitsje. As it bestân al bestiet, feroaret gewoan tagongsrjochten en bewurkje it. Bewarje it bestân, en folgjende sille wy it tagongsrjochten feroarje. Salang't wy dit skript brûke, hoege wy dat net wer te dwaan.

sudo chmod a+x /usr/bin/ascript

Perfekt. Litte wy no in skript meitsje mei de namme Setup. Earst, net om jo net te oerwinnen, mar efkes sjen nei wat myn opsetskript der útsjocht. Wy sille rinne troch wat dit skript yn jo projekt soe moatte útsjen, jo sille net alles yn myn skript nedich wêze om mei te begjinnen.

# ! / bin / bash
# Sudo Chmod A + X-skripts / Usersetup
# ./Scripts/usersetup
# SSH-keygen
# Project Directory
# Logkommando's
# Nano Config
# Git config
# Update en ynstallearje
# Kampioenskippen ynskeakelje Antivirus
# SET HOSTNAME
# Postgres ynstelle
# Ynstelle database-reservekopy
# Iptables útskeakelje
# StitDefender ynstallearje
# Postfix opset
# DIRS oanmeitsje
# VirtualsV ynstelle
# Krij en bouwe ôfhinklikens
# Stel firewall-regels yn
# Ynstallearje pypiôfhinklikens
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 ynstallaasje Operencv-byloggen Python == 4.5.5.64
# Ynstallearje CertBot
# Run certbot
# Mailserver opnij laden
# Kopiearje CERTS
# sudo cp /etc/letsencrypt/live/femmebabe.com/Privkey.pem Privy.pem
# sudo cp /etc/letsencrypt/live/femmebabe.com/cert.pem cert.pem
# PATCH VENV
# Stel brûkersynstellingen yn
# Stel tagongsrjochten yn
# Sudo chown -r team: brûkers / var / run /
# Sudo Chown Root: Root / Run / Sudo / TS -R
# sudo chmod 664 dB.Sqlite3
# Sudo Chown www-gegevens: Users dB.Sqlite3
# Kopiearje konfigurearje en tagongsrjochten ynstelle
# Ynstelle databank
# Inject Pam Config en ferwiderje defekte SSH Conconfig
# Sudo sed -i '' -e '$ d' /etc/pam.d/SSHD
# Sudo sed -i '' -e '$ D' / etc / profyl
# Kopiearje BIN-skripts en set tagongsrjochten yn
# Tsjinsten opnij laden en ynskeakelje
# Ynskeakelje apache-modules yn
# sudo a2dismod mpm_event
# sudo a2dismod mpm_worker
# sudo a2enmod mpm_prefork
# Standert side útskeakelje
# Skeakelje ús side yn
# Ferzje deponemon en opnij starte Apache, postfix en Opendkim
# Stel tagongsrjochten yn
# Ruilje konfiguraasje
# Init Caption Engine
# Setup Git
# Sjen litte IPV6 en Opendkim foar domeinkonfiguraasje
# Setup foltôge

Dat is in soad opset! Koartsein, dizze koade logs, konfigurearret Nano en git, kopiearden oer bestannen, Kontrôles postfix, konfigurearret postgix, konfigureareart iptabase), ynstalleare, downloads in antivirus, makket mappen, makket mappen, klonen Ofhinklikens, ynstalleart sertifikaten en stelt de server op, ynstalleart konfiguraasje, begjint de Sever en ynskeakelt de Sever, Conocates Wapen,Stelt tagongsrjochten yn, en printet de IP, IPV6-adres en Opendkim-toets. Frij simpel, mar it liket op in soad koade. Wy sille dit net nedich wêze, om't wy net de ôfhinklikens hawwe, wy brûke net dat selderij, selerybeat of Daphne, mar wy sille wat fan jo ynstallearje om te begjinnen. Tink derom dat dizze koade in domein hat ferklearre ferskate

Wy sille ek in domeinnamme moatte keapje (dat is in lytse jierlikse fergoeding). Ik advisearje Squarespace foar it keapjen fan in domein, har yndieling is yntuïtyf en maklik te brûken. Jo kinne elk domein fan jo kar keapje, mar ik brûk it domeinfemmebabe.com yn dit foarbyld. Sadree't jo in domein hawwe kocht, holle nei it Squarespace DNS-konfiguraasjetaniel en foegje in opdracht ta oan it wizigjen fan jo domein nei de server troch IP-adres. It soe der sa útsjen moatte:

@ A xx.xx.xx.xx

Mei de @ operator as de leger, betsjuttet alle Subdomeinen ûnder dit domein en de rootdomein sil alle trochferwize nei de server. D'r binne mear records om te ferklearjen, mar wy kinne trochgean nei dizze ienris wy ree binne om e-post te stjoeren. Hâld der rekken mei, it kin ferskate dagen duorje foardat jo mei súkses kinne stjoere fan 'e server. De DNS-records Wy binne ynstellingen sille tiid nimme om te propagearjen.

Hoe dan ek, it ienige record dat wy moatte begjinne te begjinnen is in rekord. Dus no kinne wy it ûndersteande skript ynfolje neffens ús projekt en rinne it.

Litte wy begjinne mei in lytsere opsetskript om gewoan te ynstallearjen wat wy nedich binne foar in basisútgong. Wy sille noch net safolle ôfhinklikens of postgresql brûke, wy begjinne gewoan in basis HTTP-server en soargen oer it sertifisearjen as dat dien is. Tink derom, om in HTTPS-sertifikaat te krijen en de server feilich te rinnen, wy sille in domein moatte keapje tegearre mei hiere in server. Foar no ferfange "team" yn dit bestân mei de namme fan jo brûker "Dir", mei de map fan jo projekt, en leverje jo e-post en domein ynde <>

Derneist foardat wy dizze koade útfiere, moatte wy de ynstellingen feroarje nei de Firewall De hosting-provider stipet, as ien. Normaal is dit yn 'e ljepblêd' Netwurken 'fan jo hosting provider, of as jo sels hosting binne, is it yn' e seksje 'haven troch' e grutte fan jo router. Jo wolle ek in statyske IP fia jo router ynstelle mei it adres fan jo servermasjine, as jo sels hosting brûke. Jo sille de folgjende havens moatte iepenje foar lêzen / skriuwtagong.

22 (SSH) 25 (mail) 587 (Mail) 110 (Mail client) 80 (HTTP) 443 (HTTPS)

# ! / bin / bash
# Logkommando's
# Nano Config
# Git config
# Update en ynstallearje
# Kampioenskippen ynskeakelje Antivirus
# SET HOSTNAME
# Ynstelle database-reservekopy
# Iptables útskeakelje
# VirtualsV ynstelle
# Ynstallearje CertBot
# Run certbot
# Stel brûkersynstellingen yn
# Stel tagongsrjochten yn
# Sudo chown -r team: brûkers / var / run /
# Sudo Chown Root: Root / Run / Sudo / TS -R
# Tsjinsten opnij laden en ynskeakelje
# Ynskeakelje apache-modules yn
# Ferzje deponemon en opnij starte Apache, postfix en Opendkim
# Sjen litte IPV6 en Opendkim foar domeinkonfiguraasje

Foardat jo dizze koade útfiere, soargje derfoar dat it domein dat jo hawwe kocht is ferbûn oan 'e server. Om dit te dwaan, iepenje in terminal op jo pleatslike masine, en rinne dit kommando út mei jo domein:

ping femmebabe.com # Foegje hjir jo domein yn, nei ping

As alles goed sjocht en de server stjoert, stjoert wy ree, ree om it skript te rinnen en ynstallearje pakketten, ynstallearje, ynskeakelje, ynskeakelje, ynskeakelje ús Apache-server.

Dit is net alle opset nedich om postfix te konfigurearjen, wy sille letter nei't jo letter mear ynstelle. Foar no liede dizze opsetkoade en it moat in pear minuten duorje om jo server te ynstallearjen en te sertifisearjen. Soargje der nochris, soargje derfoar dat jo namme, e-post- en domeinnamme ferfange yn it skript neffens de namme dy't jo hawwe kocht.

No't de server is foarsjoen, kinne jo nei de URL yn elke webbrowser gean en kontrolearje om te soargjen dat de server HTTPS rint. As it net is, besykje dan in skoftke te wachtsjen foar de DNS-records om it folgjende kommando op te heljen en te rinnen, om it op te nimmen om it sertifikaat opnij te besykjen:

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

Salang't jo alles korrekt hawwe konfigureare, soene jo tagong kinne ta Apache-pagina's fan APA-standert gewoan om te kennen om te witten dat jo koade wurket en in live webside werjaan. Ret's litte wy de ynstellingen bewurkje.py om ús standert debugmodus te feroarjen nei produksje. Wy sille it domein ek yn 'e ynstellingen konfigurearje, lykas ynterne IPS.

nano yourproject/settings.py

Yn 'e ynstellings, feroarje / Foegje dizze rigels ta.

# Site Config

No, wy moatte Apache2 net konfigurearje. Litte wy it CONFIG-bestân bewurkje, wy sille ynsetje mei dizze rigel:

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

Dit konfiguraasje moat ús domeinnamme hawwe yn it, en de namme fan 'e brûker en projekt. Ik brûk de domeinnamme femmebabe.com, it brûkersnamme-team, en de projektnamme Femmebabe.

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>

Soargje derfoar dat jo de namme fan it projekt, mappen fan it projekt ferfange, en domeinen yn dit foarbyldkoade by it konfigurearjen fan jo server. No, wy sille de standertide moatte útskeakelje. Dit kin dien wurde mei bash.

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

Folgjende kinne wy de standertide ynskeakelje en weromladen apache2, ek opladen, ek gebrûk fan bash. Tink derom om Femmebabe te ferfangen mei de namme fan it bestân dat jo ferklearre as jo yn / etc / apache2 / sites-beskikber bewurkje /.

sudo a2ensite femmebabe-le-ssl
sudo systemctl reload apache2

Gean werom nei jo domein yn 'e Navbar. Jo moatte de side sjen dy't jo konfigureare yn jo webbrowser. Lokwinsken! As jo it net sjogge, moatte jo miskien wat wizigingen meitsje. Besoargje de ynstellingen yn jo projekt, apache-konfiguraasje, en soargje derfoar dat jo gjin flaters hawwe, en de folgjende kommando's útfiere om it projekt te kontrolearjen.

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

As jo flaters hawwe yn jo Python-projekt, traapje se dan wêr't se binne en se reparearje. Jo kinne miskien net jo flaters sjen, ôfhinklik fan wêr't se binne, dus as jo in flater hawwe, dat "befolking is, is it folgjende bestân yn 'e firtuele omjouwing, register.py, om de flater te eksposearjen, om de flater te eksposearjen,

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

Rôlje nei line 83, wêr't dizze runtime-flater wurdt opbrocht (ferheegje (befolke () is net reentrarren ") en foegje in reaksje ta, en foegje dan ta, mei deselde yndruk, sels.app_configs = {}. Dit liket derop:

                # Foarkom dat Reentrant ropt om AppConfig.ate te foarkommen ()
                # Metoaden twa kear.
# RuntimeError ferheegje ("befolke () is gjin Reentrant")

Jo kinne dan it projekt opnij kontrolearje en de flater eksposearje.

python manage.py check

Dan kinne jo de flater sjen en it reparearje. As jo it hawwe fêste en de koade kompilyen mei gjin flaters, soargje der dan wis fan it bestân werom te feroarjen, sadat it sa liket:

                # Foarkom dat Reentrant ropt om AppConfig.ate te foarkommen ()
                # Metoaden twa kear.
# self.app_configs = {}

Overe de server is online, as wy fierder feroaringen meitsje, moatte wy it folgjende kommando brûke om de server te laden:

sudo systemctl reload apache2

Geweldich! Mar wat oer it ferstjoeren fan e-post? Om te begjinnen mei ferstjoeren fan e-post, sille wy earst de domeinkonfiguraasje moatte bywurkje. Dit soe moatte wêze yn jo DNS-paniel yn Squarespace, of hokker domeinnamme registrar jo hawwe keazen. Wy sille ek om konfiguraasje moatte ynstallearje en tafoegje en in pear kommando's útfiere.

Litte wy earst it IPV6-adres krije fan 'e server. Wy sille dan jo DNS iepenje en de records tafoegje.

Om it IPV6-adres fan 'e server te krijen, brûk dit kommando:

ip -6 addr

No, wy kinne de folgjende records tafoegje oan 'e DNS-ynstellingen. Myn records sjogge der sa út. Foar jo records moatte jo lykwols it IP-adres ferfange troch jo IP (net 75.147.182.214, dat is mines). Foegje jo domein ek ta yn plak fan femmebabe.com, lykas ek jo ipv6-adres fûn mei it foarige kommando (jo kinne mines net brûke, fe80 :: FFF: FFF: FFF: 3E02). Meitsje jo no gjin soargen oer de domeinkey, dit is makke as wy postfix ynstelle, de e-postserver, mei OPENDKIM, en de kaai printsje. Wy silledit konfigurearje

@ IN 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: FFF: 3E02 ~ All

default._bimi Txt N / a v = bimi1; l = https: //femmebabe.com/media/static/femmebabe.svg

_dmarc Txt N / a v = dmarc1; P = Gjin

Sendonly._Domaierkey Txt N / a

No, wy moatte wat oanhâldende konfiguraasje tafoegje foar postfix. Alles wat wy hoege te dwaan is te soargjen dat wy de domeinnamme, femmebabe ferfange, mei de domeinnamme dy't jo brûke. Litte wy ien fan alle konfiguringsbestannen ien sjen, en ynstallearje se yn in map neamd Conne Config yn ús projekt, om it OS te ynstallearjen.

nano config/etc_postfix_main.cf

Foegje dizze tekst ta oan it bestân

# Sjoch /usr/share/postfix/main.cf.Dist foar in kommentearre, mear folsleine ferzje
# Debian spesifyk: spesifisearje in bestânsnamme sil de earste feroarsaakje
# Line fan dat bestân om te wurde brûkt as de namme.  De Debian standert
# is / etc / postnamme.
# Myorigin = / etc / MailName
# APPENDEN. WOMENAIN IS DE MUA'S JOB.
# Unkommentearje de folgjende rigel om "fertrage e-post" warskôgingen te generearjen




# Milterkonfiguraasje

Folgjende konfiguer!

nano config/etc_postfix_master.cf

Foegje dizze rigels ta:

# 
# Postfix master proses konfiguraasjetriem.  Foar details oer it formaat
# fan it bestân, sjoch de master (5) hânmjittich pagina (kommando: "man 5 master" of


# Ferjit net om "postfix opnij laden" útfiere nei it bewurkjen fan dit bestân.
# 

# Tsjinstype privee unpriv choot wekker Maxproc-kommando + args

# =====================================================================
# SMTP INET N - Y - 1 postscreen
# SMTPD PASS - - y - - SMTPD
# DNSBLOG UNIX - - y - 0 dnsblog
# TlSproxy UNIX - - y - 0 tlsproxy
# Kies ien: yntsjinjen yntsjinje foar loopback-kliïnten allinich, as foar elke klant.
# 127.0.0.1:Submission INET N - Y - SMTPD
# -o syslog_name = Postfix / yntsjinjen

# -o smtpd_sasl_auth_enable = ja
# -o smtpd_tls_auth_only = ja

# -o SMTPD_CLIENTS_RESTRIDS = $ MUA_CLIENT_RESTRIDIictionNS
# -o SMTPD_HELO_RESTRIDS = $ mua_helo_restriksjes
# -o SMTPD_SENERE_RESSIRTS = $ MUA_SENDER_RESTRICTIONS
# -o SMTPD_recipient_restriksjes =
# -o SMTPD_RELAY_RESTRICTIONS = PERMIT_SASL_AATHENTICATED, ôfwize
# -o milter_macro_daemon_name = oarsprong
# Kies ien: SMTPS ynskeakelje foar loopback-kliïnten allinich, as foar elke klant.
# 127.0.0.1:MTPS INET N - Y - - SMTPD
# SMTPS INET N - Y - SMTPD
# -o syslog_name = Postfix / SMTPS

# -o smtpd_sasl_auth_enable = ja
# -o SMTPD_REJECT_UNLISTED_RECIPIENT = NO
# -o SMTPD_CLIENTS_RESTRIDS = $ MUA_CLIENT_RESTRIDIictionNS
# -o SMTPD_HELO_RESTRIDS = $ mua_helo_restriksjes
# -o SMTPD_SENERE_RESSIRTS = $ MUA_SENDER_RESTRICTIONS
# -o SMTPD_recipient_restriksjes =
# -o SMTPD_RELAY_RESTRICTIONS = PERMIT_SASL_AATHENTICATED, ôfwize
# -o milter_macro_daemon_name = oarsprong
# 628 inet n - y - - qmqpd
# qmgr unix n - N 300 1 OQMGR
# -o smtp_helo_timeout = 5 -o smtp_connect_timeout = 5
# 
# ================================================================
# Ynterfaces oan software net-postfix. Wês wis dat jo de hantlieding ûndersykje
# Siden fan 'e software net-postfix om út te finen hokker opsjes it wol.
# 
# In protte fan 'e folgjende tsjinsten brûke de postfix-piip (8) levering
# agint.  Sjoch de piip (8) Man-pagina foar ynformaasje oer $ {Untfanger}
# en oare opsjes foar ferstjoeren fan berjochten.
# ================================================================
# 
#  maildrop. See the Postfix MAILDROP_README file for details.
#  Also specify in main.cf: maildrop_destination_recipient_limit=1
# 
# 
# ================================================================
# 
# Resinte Cyrus ferzjes kinne it besteande "LMMTP" Master.CF yngong brûke.
# 
# Spesifisearje yn Cyrus.Conf:
# lmtp cmd = "lmtpd -a" harkje = "Localhost: LMMTP" Proto = TCP4
# 
# Spesifisearje yn Main.CF ien of mear fan 'e folgjende:
# Mailbox_transport = LMTP: Inet: LocalHost
#   virtual_transport = lmtp:inet:localhost
# 
# ================================================================
# 
# Cyrus 2.1.5 (Amos Gouaux)
# Spesifisearje ek yn Main.CF: Cyrus_Destination_Recipient_Limit = 1
# 
# cyrus     unix  -       n       n       -       -       pipe
#   flags=DRX user=cyrus argv=/cyrus/bin/deliver -e -r ${sender} -m ${extension} ${user}
# 
# ================================================================
#  Old example of delivery via Cyrus.
# 
# old-cyrus unix  -       n       n       -       -       pipe
# flaggen = r brûker = cyrus argv = / cyrus / bin / levere -e -M $ {útwreiding} $ {uso {user}
# 
# ================================================================
# 
# Sjoch it postfix Uucp_ReadMe-bestân foar konfiguraasjedetails.
# 
# 
# Oare eksterne leveringsmetoaden.
# 

En de opendkim-konfiguraasje. Opendkim identifiseart e-postervers mei domeinskoetsen om se feiliger te meitsjen. Sûnder it wurdt net ûndertekene en kin it miskien net oan in postfak meitsje.

nano config/etc_default_opendkim

Foegje dizze rigels ta:

# Opmerking: dit is in legacy-konfiguraasjetriem. It wurdt net brûkt troch de OpenDkim
# systemd tsjinst. Brûk asjebleaft de oerienkommende konfiguraasjeparameters yn
# /etc/opendkim.conf ynstee.
# 
# Earder soe men de standertynstellingen hjir bewurkje, en dan útfiere
# /LIB/OPEDKIM/OPENDKIM.S FERSEE.GENERATE om systemd oerskriuwing te generearjen by
# /etc/systemd/systeem/system/opendkim.service.d/OVride.conf en
# /etc/tmpfes.D/opendkim.conf. Wylst dit noch mooglik is, is it no
# Oanrikkemandearre om de ynstellingen direkt yn /etc/opendkim.conf direkt te passen.
# 
# Daemon_opts = ""
# Feroarje nei / var / spool / postfix / run / opendkim om in unix-socket te brûken
# Postfix yn in chroot:
# Rundir = / var / spool / postfix / run / opendkim
# 
# Unkomment om in alternatyf socket op te jaan
# Tink derom dat it ynstellen fan dit elke socketwearde sil oerdrage yn Opendkim.conf
# Standert:
# Harkje op alle ynterfaces op poarte 54321:
# Socket = Inet: 54321
# Harkje op Loopback op haven 12345:
# Socket = Inet: 12345 @ localhost
# Harkje op 192.0.2.1 op poarte 12345:
# Socket = Inet: 12345@192.0.2.1

nano config/etc_dovecot_conf.d_10-master.conf

Foegje dizze rigels ta:

# default_Process_Limit = 100
# Standert_client_limit = 1000
# Standert VSz (Virtuele ûnthâld grutte) Limyt foar tsjinstproses. Dit is foaral
# bedoeld om prosessen te fangen en te fermoardzjen dy't ûnthâld lekt foardat se ite
# alles.
# default_vsz_Limit = 256m
# Oanmelde-brûker wurdt yntern brûkt troch oanmeldprosessen. Dit is it meast net yntreden
# Meidogger yn Doecot systeem. It moat hielendal gjin tagong hawwe ta neat.
# Standert_login_user = DOVENULL
# Ynterne brûker wurdt brûkt troch unprivilegearre prosessen. It moat apart wêze
# Oanmelde brûker, sadat oanmeldprosessen oare prosessen net fersteure.
# default_internal_user = Dovecot
    # haven = 143
    # Port = 993
    # SSL = ja
  # Oantal ferbiningen om te behanneljen foardat jo begjinne mei in nij proses. Typysk
  # De iennige nuttige wearden binne 0 (ûnbeheind) of 1. 1 is feiliger, mar 0
  # is rapper. <DOC / Wiki / LoginProcess.txt>
  # Service_count = 1
  # Oantal prosessen om altyd te wachtsjen op mear ferbiningen.
  # Process_Min_avail = 0
  # As jo Service_count = 0 ynstelle, moatte jo wierskynlik dit groeie.
  # vsz_limit = $ default_vsz_limit
    # haven = 110
    # port = 995
    # SSL = ja
    # Port = 587
  #  Create inet listener only if you can't use the above UNIX socket
  # inet_listener lmtp {
    # Foarkom dat LMTP sichtber is foar it heule ynternet
    # adres =
    # haven =
  # }
  # It measte fan it ûnthâld giet nei mmap () ing-bestannen. Jo moatte dit miskien ferheegje
  # beheine as jo enoarme postfakjes hawwe.
  # vsz_limit = $ default_vsz_limit
  # Maks. Oantal IMAP-prosessen (ferbiningen)
  # ProSce_Limit = 1024
  # Maks. Oantal POP3-prosessen (ferbiningen)
  # ProSce_Limit = 1024
  # Maks. Oantal SMTP-yntsjinjen prosessen (ferbiningen)
  # ProSce_Limit = 1024
  # Auth_socket_path-punten nei dizze userdb socket. It is typysk
  # brûkt troch Doecot-LDA, Doeadm, mooglik IMAP-proses, ensfh. Brûkers dy't hawwe
  #  full permissions to this socket are able to get a list of all usernames and
  # Krij de resultaten fan 'e userDB-útstrieling fan elkenien.
  # 
  # De standert 0666-modus kinne elkenien ferbine mei de socket, mar de
  # usherdb lookups sil allinich slagje as de userdb in "uid" fjild werom jout dat
  #  matches the caller process's UID. Also if caller's uid or gid matches the
  #  socket's uid or gid the lookup succeeds. Anything else causes a failure.
  # 
  # Om de beller folsleine tagongsrjochten te jaan om alle brûkers te sykjen, set de modus oan
  #  something else than 0666 and Dovecot lets the kernel enforce the
  # Fergunningen (bgl. 0777 kinne elkenien folsleine tagongsrjochten kinne).
  #  Auth worker process is run as root by default, so that it can access
  #  /etc/shadow. If this isn't necessary, the user should be changed to
  #  $default_internal_user.
  # user = root
  #  If dict proxy is used, mail processes should have access to its socket.
  #  For example: mode=0660, group=vmail and global mail_access_groups=vmail
    # Mode = 0600
    # user = 
    # group = 

Soargje der nochris foar it domein yn al dizze bestannen, femmebabe.com, mei it domein dat jo hawwe selektearre. Bewurkje it folgjende bestân, Doecot's Config,

nano config/etc_dovecot_dovecot

En foegje dizze rigels ta

##  Dovecot configuration file
# As jo haast binne, sjoch, sjoch http://wiki2.dovecot.org/quickConfiguration
#  "doveconf -n" command gives a clean output of the changed settings. Use it
# Yn plak fan kopiearje en plakken by it pleatsen by it pleatsen nei de Doevasme-mailing-list.
# '# ' character and everything after it is treated as comments. Extra spaces
# en ljeppers wurde negeare. As jo ien fan dizze eksplisyt wolle brûke, set dan de
# value inside quotes, eg.: key = "#  char and trailing whitespace  "
# De measte (mar net alle) ynstellings kinne wurde oerdreaun troch ferskate protokollen en / of
#  source/destination IPs by placing the settings inside sections, for example:
# Protokol IMAP {}, Lokaal 127.0.1 {}, op ôfstân 10.0.0.0/8 {}
# Standertwearden wurde werjûn foar elke ynstelling, it is net fereaske oan unkomment
# dy. Dit binne útsûnderingen hjirop: gjin seksjes (bgl. Nammeromte {})
# OF PLUESIN-ynstellingen wurde standert tafoege, se wurde allinich as foarbylden neamd.
# Paden binne ek gewoan foarbylden mei de echte standertpunten dy't binne basearre op konfiguraasje
#  options. The paths listed here are for configure --prefix=/usr
# --Sysconfdir = / etc --Calstatedir = / var
# Ynstalleare protokollen ynskeakelje
# In komma skieden list mei ips as hosts wêr't jo moatte harkje foar ferbiningen.
# "*" Liesens yn alle IPv4 ynterfaces, "::" harket yn alle IPV6-ynterfaces.
# As jo net-standert havens wolle opjaan of wat komplekser,
# Bewurkje Contr.. / Master.conf.
# harkje = *, ::
# Basis Directory Wêr moatte jo Runtime-gegevens opslaan.
# base_dir = / var / run / dovecot /
# Namme fan dit eksimplaar. Yn mear-eksimplaar ynstelle Doeadm en oare kommando's
# kin -i <eksimplaar_namme> brûke om te selektearjen hokker eksimplaar wurdt brûkt (in alternatyf
#  to -c <config_path>). The instance name is also added to Dovecot processes
# yn PS-útfier.
# INTANCE_NAME = Doecot
# Groetnisberjocht foar kliïnten.
# Login_Greeting = Doevet klear.
# Romte skieden list mei fertroude netwurk berik. Ferbinings fan dizze
# IP's meie har IP-adressen en havens oerdrage (foar oanmelding en
# foar ferifikaasje kontrôles). Skeakelje_Plaintext_auth wurdt ek negeare foar
# dizze netwurken. Typysk soene jo hjir jo IMAP-proxy-servers opjaan.
# login_trusted_networks =
# List fan romte skieden fan oanmeldings tagongskontrôle Sockets (bgl. TCPWRap)
# login_access_sockets =
# Mei proxy_maybe = Ja as proxy-bestimming oerienkomt mei ien fan dizze IPS, doch net
# proxying. Dit is net nedich normaal, mar kin nuttich wêze as de bestimming
# IP is it bgl. in IP fan in laden Balancer.
# autor_proxy_self =
# Sjen litte mear ferbannepros-titels (yn PS). Toant op it stuit Dragersnamme en
# IP-adres. Nuttich foar it sjen fan wa't de IMAP-prosessen eins brûke
# (bgl. Skermers ferstjoeren as deselde UID wurdt brûkt foar meardere akkounts).
# tiidwurdse_proctitle = nee
# Moatte alle prosessen wurde fermoarde as Doecot Master Proces ôfslút.
# It ynstellen fan dit oant "nee" betsjut dat Doecot kin wurde opwurdearre sûnder
# Begjinde besteande kliïntferbiningen om te sluten (hoewol dat ek koe wêze
# in probleem as de upgrade is bgl. fanwegen in befeiligingsfix).
# shutdown_clients = ja
# As net-nul, rint postkommando's fia dizze protte ferbiningen nei Daveadm-server,
# ynstee fan se direkt yn itselde proses te rinnen.
# Doeadm_worker_count = 0
# Unix socket as host: Port brûkt foar ferbining mei Doveadm-server
# Doeadm_socket_path = Doeadm-server
# Romte skieden list mei omjouwingsfariabelen dy't wurde bewarre op Doecot
# Begjin en trochjûn oan al syn bernprosessen. Jo kinne ek jaan
# KEY = Wearde pearen om altyd spesifike ynstellingen te stellen.
# ymport_enbúsjoeren = tz
## 
## Ynstellings foar Wurdboek Server
## 
# Wurdboek kin brûkt wurde om kaai te bewarjen = weardelisten. Dit wurdt brûkt troch ferskate
# Plugins. It wurdboek kin direkt wurde tagonklik foar ofwol in
# Wurdboek Tsjinner. De folgjende dict-dict blokkeart kaarten wurdboek nammen oan uris
# doe't de server wurdt brûkt. Dizze kinne dan wurde ferwiisd mei uris yn formaat
# "Proxy :: NAME>".
  # quota = mysql: /etc/dovecot/dovecot-dd-sqf.xqf.exd
# De measte fan 'e eigentlike konfiguraasje krijt hjirûnder opnommen. De bestânsnammen binne
# Earst sorteare troch har ASCII-wearde en parset yn dy folchoarder. De 00-foarheaksel
# Yn bestânsnammen binne bedoeld om it makliker te meitsjen om de bestelling te begripen.
# In konfiguraasje kin ek besocht te wurden opnommen te wurden sûnder in flater te jaan as
# It is net fûn:
# Lit DoVecot harkje nei alle ynfierferbiningen (IPv4 / IPV6)

Foegje in wachtwurd ta foar de Dovecot-brûker:

nano config/etc_dovecot_passwd

It earste diel fan it bestân, foar de kolon, is de brûkersnamme. It lêste diel, "YOURPASSWORD", tsjut it wachtwurd dat jo jo e-postserver wolle jaan.

team:{plain}yourpassword

Folgjende, de Opendkim Config

nano config/etc_opendkim.conf

En foegje dizze rigels ta:

# Dit is in basiskonfiguraasje foar ûndertekenjen en te kontrolearjen. It kin maklik wêze
# Oanpast om in basisynstallaasje te passen. Sjoch de opendkim.conf (5) en
# /usr/dare/doc/opendkim/examples/opendkim.conf.sample foar Complete
# Dokumintaasje fan beskikbere konfiguraasjeparameters.
# Logwhy nee
# Mienskiplike ûndertekening en ferifikaasjeparameters. Yn Debian is it "fan" koptekst
# Oversignearre, om't it faaks de identiteits-kaai brûkt wurdt troch reputaasjeystemen
# en dus wat befeiligingsgefoelich.
# Undertekenjen fan domein, selector, en kaai (fereaske). Bygelyks, ûndertekenjen útfiere
# FOAR DOMAIN "AFFORTOME.com" Mei Selector "2020" (2020._domajiny.example.com),
# Mei de privee kaai opslein yn /etc/dkimkeys/example.Privearje. Mear granulêr
# Opsjes foar ynstellen kinne fûn wurde fûn yn /usr/Share/DOC/OPENDKIM/README.OPDKIM.
# Domain foarbyld.com
# Selector 2020
# Keyfile /etc/dkimkeys/example.Private
# Yn Debian rint Opendkim as brûker "Opendkim". In umask fan 007 is fereaske wannear
# Mei help fan in lokale socket mei MTA's dy't tagong hawwe ta de socket as net-befoarrjochte
# brûker (bygelyks postfix). Jo moatte miskien brûker tafoegje "postfix" tafoegje oan groep
# "Opendkim" yn dat gefal.
# Socket foar de MTA-ferbining (fereaske). As de MTA yn in chroot-finzenis is,
# It moat wurde garandearre dat de socket tagonklik is. Yn Debian rint postfix yn
# in chroot yn / var / spool / postfix, dêrom soe in unix socket moatte wêze
# konfigureare lykas werjûn op 'e lêste rigel hjirûnder.
# Socket Lokaal: /run/opendkim/opendkim.sock
# Socket Inet: 8891 @ localhost
# Socket Inet: 8891
# HOSTS FOOS DAT OM OM RJOCHTS OF FERSKILLEN DAN VERJE, VERSITE IS 127.0.0.1. Sjoch de
# Operaasje Sifting fan OpenDkim (8) foar mear ynformaasje.
# InternalHosts		192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12
# It Trust Anchor ynskakelt Dnssec. Yn Debian is it fertrouwen ankerbestân levere
# troch it pakket DNS-woartelsgegevens.
# NEVERSERVERS 127.0.0.1
# Kaart-domeinen yn 'e adressen nei kaaien dy't brûkt wurde om berjochten te ûndertekenjen
#  A set of internal hosts whose mail should be signed

nano config/etc_default_opendkim

En foegje dizze rigels ta

# Opmerking: dit is in legacy-konfiguraasjetriem. It wurdt net brûkt troch de OpenDkim
# systemd tsjinst. Brûk asjebleaft de oerienkommende konfiguraasjeparameters yn
# /etc/opendkim.conf ynstee.
# 
# Earder soe men de standertynstellingen hjir bewurkje, en dan útfiere
# /LIB/OPEDKIM/OPENDKIM.S FERSEE.GENERATE om systemd oerskriuwing te generearjen by
# /etc/systemd/systeem/system/opendkim.service.d/OVride.conf en
# /etc/tmpfes.D/opendkim.conf. Wylst dit noch mooglik is, is it no
# Oanrikkemandearre om de ynstellingen direkt yn /etc/opendkim.conf direkt te passen.
# 
# Daemon_opts = ""
# Feroarje nei / var / spool / postfix / run / opendkim om in unix-socket te brûken
# Postfix yn in chroot:
# Rundir = / var / spool / postfix / run / opendkim
# 
# Unkomment om in alternatyf socket op te jaan
# Tink derom dat it ynstellen fan dit elke socketwearde sil oerdrage yn Opendkim.conf
# Standert:
# Harkje op alle ynterfaces op poarte 54321:
# Socket = Inet: 54321
# Harkje op Loopback op haven 12345:
# Socket = Inet: 12345 @ localhost
# Harkje op 192.0.2.1 op poarte 12345:
# Socket = Inet: 12345@192.0.2.1

As wy ree binne om ús postfix-server yn te stellen, sille wy de ûndersteande koade útfiere, mei de passende domeinnamme ynbêde. Begjin troch in skript te meitsjen

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

No, yn Nano, de tekstbewurke, bewurkje dit bestân, sadat it jo domeinnamme omfettet yn plak fan femmebabe.com.

# ! / bin / bash
# Postfix opset

Rinne no it foltôge skript om postfix te konfigurearjen, Opendkim en Doecot.

./scripts/postfixsetup

Sadree't dit skript hat útfierd, kopiearje, kopiearje it de lêste rigel it ôfdrukken en plakke it yn jo DNS-konfiguraasje as de wearde foar Sendonly._domaining. Dit is de OPENDKIM-toets brûkt om jo domein te identifisearjen by it ferstjoeren fan feilige post.

Geweldich! Binnen in pear dagen soene jo e-post kinne stjoere fan 'e server levere dat alles korrekt is konfigureare.

As jo de DNS krekt konfigureare foar jo e-postserver, soe it minder dan 72 oeren moatte nimme foar de records om te aktualisearjen. It is normaal folle rapper. Jo kinne kontrolearje as jo server wurket mei dit kommando te brûken, levere jo e-post:

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

If everything appears to be working correctly, you should be able to send email with your server. If it's not working, try looking at the logs to see what the error might be.

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

Dit sil Verbare ynformaasje oanbiede oer e-post dy't wurde stjoerd troch de server en oft it goed wurket. Jo soene de e-post yn kinne sjen yn jo Postfekje, as it net is, kontrolearje dan jo SPAM-map.

Jo moatte ek jo ynstellingen moatte konfigurearje yn jo ynstellings.py sadat jo e-postserver kin petearje mei jo Django-app, it projekt. Foegje of ferfange dizze rigels yn jo ynstellings

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

Tink derom dat wy in konfiguraasje brûke om it wachtwurd te krijen. Litte wy dit bestân laden yn 'e ynstellingen lykas dat, oan it begjin fan it bestân:

#  Open and load config

Litte wy dit bestân oanmeitsje en in geheime kaai tafoegje oan it, lykas ek it post wachtwurd. Om in geheime kaai te generearjen, brûk dit kommando, mei hokker lingte jo wolle oan it ein:

openssl rand -base64 64

No, kopiearje de tekst dy't OpenSSL generearre is en bewurkje /etc/config.json

sudo nano /etc/config.json

Foegje de folgjende rigels ta oan jo bestân ta, mei de kaai dy't OpenSSL generearre is as de geheime kaai.

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

JSON-formaat is ienfâldich en maklik te brûken, kinne wy oare kaaien ferklearje dat wy ek wolle brûke, en hâlde se yn ús projekt dat oare brûkers net oan har kinne skriuwe en sa kinne se allinich net skriuwe. Dit is oanrikkemandearre praktyk foar API-toetsen, wêrfan wy hjir mear dan in pear sille brûke.

Jo wolle jo projekt ek reservearje om te soargjen dat alles bewarre wurdt en jo kinne jo wurk letter weromhelje, sels as jo gjin server wolle hiere.

sudo backup

Besykje no in HTML-e-post te ferstjoeren fan 'e webserver, leverje ien út' e kommando-rigel te ferstjoeren. Fraach jo brûkersynfang yn 'e Shell, en stjoer in HTML-e-post nei dy brûker fia Django. Feroarje myn namme yn 'e koade, Charlotte, nei jo brûkersnamme.

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()

As it earste kommando net wurket, soargje der dan wis om te brûken

source venv/bin/activate

Overe alles is korrekt ynsteld, jo sille no in wolkom e-post krije yn jo postfak stjoerd troch jo web-app. Goede baan! Jo binne in lange wei kommen.

Ik woe tafoegje, as jo oait muoite hawwe mei alle flukten by alle flaters, wylst jo wurkje oan in projekt, nim dan gerêst om nei antwurden te sykjen en om help te freegjen en om help om help. Google, ûnder oare sykmasjines, binne geweldige boarnen om te sykjen nei programmearjen help. Sykje gewoan nei de flater dy't jo krije, en jo sille kinne sjen hoe't oare minsken it probleem oplosse. Jo binne ek wolkom om kontakt mei my op te nimmen, jo oplieders (dosinten, heechleararen, tutors), alle leeftydsgenoaten op it ynternet dy't te krijen binne foar programmearringHelp, of rieplachtsje dit boek opnij as oare boarnen om oplossingen te finen oan 'e problemen dy't jo hawwe ûnderfûn. Ik begryp dat dit net maklik is, mar sels as jo yn dit fier hawwe lêzen en jo gjin koade skriuwe, learje jo in protte oer it bouwen fan in webapp. Pat josels op 'e rêch, jo dogge in geweldich

Tige tank foar it nimmen fan de tiid om dizze tredde edysje Web Untwikkelingsgids te lêzen. Yn takomstige edysjes sil ik mear fan 'e wichtige foarbylden omfetsje besprutsen yn it begjin fan it dokumint en wy sille folle djipper dûsje yn' e wrâld fan software en hardware-ûntwikkeling. Bliuw ôfstimd foar wat der komt, en ik sjoch út nei jo te learen hoe't jo ongelooflijke software moatte bouwe. Sjoch dy yn 'e folgjende edysje!