Praktisk nettbasert dyp læring og sikkerhet ved eksempel Tredje utgave Charlotte Harper 3. juli 2024 Oppdatert/konvertert 3. juni 2025

Forord:

Sikkerhetshensyn i å bygge programvare for nettet er en viktig del av enhver webutviklers plan og utførelse mens du konstruerer en prototype som er pålitelig, stabil og nyttig for praktiske formål. DOM (Document Object Markup), med implementeringen av HTML, JavaScript og CSS, samt backend -programvare som implementerer Python, C/C ++, Java og Bash, gir nettutviklere frihet og kraft til å skape et bredt prosjekter som gir deg en rekke forskjellige prosjekter, og som gir et stort utvalg av å gi deg et bredt. Sluttbruker som ønsker å drepe tid eller få noe gjort på internett, vanligvis på en smarttelefonenhet på berøringsskjerm. De fleste mennesker ville ikke engang vite hvor de skal begynne når de vil bygge et nettsted fra bunnen av, de vil ha en tendens til å starte på en annen persons nettsted og bygge noe begrenset i funksjonalitet, pålitelighet, brukervennlighet og spesielt kreativitet når de kunne ha hatt alle de siste kraftige verktøyene til disposisjon for å bygge noe nyttig uten å kaste bort tid på å trykke på knappen, og spesielt kaste bort penger til å kunne bruke dyre abonnement. Hvis du har noen minutter til å lese gjennom denne boken og lære hva jeg vil lære deg, eller til og med snakke med meg personlig om målene dine og få litt veiledning i riktig retning, og er motivert til å lære å kode og skrive din egen programvare, ta denne boken hjem og sette av litt tid til å lære å bygge det neste innflytelsesrike, kraftige, strømlinjeformede og viktige nettet ditt, et nettsted som er alt på deg.

Om meg: Jeg er en programvareutvikler med et bredt spekter av erfaring innen C/C ++, Java, Python, HTML, CSS og JavaScript. Jeg bygger nettsteder folk vil bruke, vil besøke og til og med bli avhengige av å bruke bare for å lære, gjenskape og drepe tid, og viktigst av alt, jeg selger programvare. Hvis du hadde en ide om nøyaktig hvordan du ønsket at et nettsted skulle se og fungere, var du villig til å støtte meg slik at jeg kan imøtekomme mine egne behov mens jeg møter dine, og du er villig til å dekke kostnadene ved å drive et nettsted selv, ville jeg bygge deg den neste YouTube, Tiktok, Twitter, Google eller til og med en høyteknologisk sikkerhetsapp bare du har tilgang til. I stedet for å prøve å selge deg tiden min, prøver jeg å kjøpe din: Jeg vil snakke deg om å bygge en app (nettsted) selv med informasjonen som allerede eksisterer, og lære deg hva du trenger for å være en uavhengig programvareutvikler, gründer, og lede en vellykket karriere innen det feltet du ønsker. Og la meg være tydelig, utdannelsen jeg gir deg vil være uformell. Du kan gå på skole og lære alt dette med en formell utdanning, eller til og med lese denne boken på skolen, fullføre oppgavene dine og ta bort mye fra utdannelsen din, men jeg vil ikke formelt sette deg i det varme setet og be deg om å fullføre oppgaver. Jeg er ikke din professor, du kan tenke på meg som en venn som vil veilede deg mot en karriere drevet av din egen personlige suksess. Og jeg selger ikke suksessen din heller, du må kjøpe den med tiden din. Å lære å kode har en bratt læringskurve og var aldri lett, eller til og med antatt å være. Du må jobbe så hardt som du kan og fortsette å prøve å mislykkes og prøve igjen selv når du er frustrert for å lære og bygge apper selv. Det er i selve koden. Kode drives av en kompilator som er designet for å gi programmererfeilmeldingene, og disse vil lære deg hvordan du skal kode, selv om du bare kopierer feilen i søkemotoren og leser andre menneskers eksempler. Og jeg må si, du trenger ikke å være ekstremt rik, smart, vellykket eller til og med detaljorientert eller organisert for å bygge en app. Datamaskinen tar seg av den organisasjonen for deg. Du trenger bare å holde ut gjennom prøving og feiling, opprettholde fokus og jobbe hardt på det du gjør, og du vil ha en veldig vellykket karriere i hele det du gjør.

Hvem jeg er: Jeg er klar over at den siste delen handlet mer om læring og at du tar vei fra denne boken. Hvem er jeg akkurat? Det er et komplisert spørsmål. Jeg er uklar på det selv, ettersom jeg lider av medisinske tilstander som kan gjøre det vanskelig for meg å til og med kode eller skrive denne boken til tider, mens jeg presenterer utfordringer med sosialisering og identitetsproblemer som gjør livet mitt vanskeligere når det gjelder å introdusere meg selv. Kort sagt, hvis du leser denne boken, tok du den med hjem fordi du snudde gjennom den og trodde den var nyttig, eller selv om du bare leste så langt inne, for deg er jeg et lignende individ som vil se at du lykkes i alt du gjør. Jeg er en ingeniør selv, en programvareutvikler og en student, og jeg skriver denne boken for andre studenter som ønsker å gjøre livene sine lettere ved å ha en håndbok over programvaren de trenger å gjøre livet lettere ved å gi eksempler på å kopiere den som passer sammen som et stort puslespill til en fungerende, nyttig, stor, funksjonell, sammenhengende og engasjerende app som kan føre til å lykkes. Stort sett er det dette jeg gjør: Jeg bygger apper for å hjelpe meg selv og andre mennesker til å lykkes. Jeg er også forfatter, selv om dette er min første publikasjon som jeg har tenkt å fullføre for å sette sammen porteføljen min i et nyttig dokument, og jeg er også kunstner. Jeg vil innrømme dette for deg, jeg er liksom en merkelig person. Jeg er ikke perfekt, jeg har hatt innløp med loven som til og med førte meg til å forlate høyskoler og universiteter og forlate stater for å prøve å gi et navn for meg selv med mer suksess. Jeg er en kvinne ved fødselen, jeg bruker sminke, tar bilder av meg selv, bruker kjoler og andre kvinneklær, og jeg holder meg bevisst på meg selv som en kvinne av natur. Jeg har hatt problemer med andre mennesker i det siste som fører til kamp med å skrive og bygge webapps, og jeg beklager at jeg ikke har klart å få denne boken i hendene før: du trengte dette. Du vil lese og skrive kode som ser ut som min og fungerer som min og gjør det samme, men enda bedre, for hvis du har råd til å kjøpe denne boken i stedet for å mase tastaturet som jeg gjør bare for å lage en bok selv og spør penger for den, har du ressursene du trenger for å lykkes i livet ditt. Jeg hadde alle slags problemer med familieoppvekst, helsemessige forhold, leger, media og loven, og koden min gjenspeiler dypt kampen som er feminisme og kvinnelig natur i en delt og frustrert verden. Imidlertid er denne boken noe jeg bryr meg dypt om, babyen min, porteføljen min og levebrødet mitt, så jeg setter pris på din vurdering når du tar teksten hjem og porer nøye over den for å lære av meg. Husk at jeg ikke er perfekt, denne boken vil ha feil, revisjoner og nye utgaver, og du må tenke med din logiske hjerne så godt du kan for å få en vellykket opplevelse med skrivingen min. Forstå også at jeg mener godt for deg selv når du møter utfordringer når du skriver. Tenk på det slik: Når du bare kan leie et datasystem for å gjøre alt du muligens kan forestille deg i det digitale rommet, lagre all informasjonen du møter, analysere og organisere den og komme til å forstå den, vil du uunngåelig møte vanskeligheter med informasjonen du inntar og til og med publisere. Jeg forteller deg dette fordi jeg møter de samme vanskene. Bruk denne boken på egen risiko, arbeid med samfunnet og lokalsamfunnene dine som er tilgjengelige for å bygge programvare innen trygge omgivelser, og ikke ta ting til personlig når du mislykkes eller til og med lykkes på feil måte: det var slik jeg kom så langt, og hvorfor jeg kan gi deg denne teksten og hjelpe deg å lykkes uten å avvike på en vei til å få en global takk for en globalt. som vi vil jobbe, Internett. Du er kanskje ikke veldig kjent med hvem jeg er med bare noen få ord, men jeg oppfordrer deg til å lese videre, du vil bli kjent med meg når du fortsetter å lese og forstå meg mens du bygger dine egne prosjekter for å fullføre arbeidet ditt. Det vil ikke være lekser med denne boken, så lenge professorene eller lærerne dine ikke tildeler deg noen, men jeg oppfordrer deg til å bygge en portefølje av prosjekter selv når du leser med, samt et capstone -prosjekt som viser hvordan du kan bruke det du har lært. Capstone -prosjektet mitt er grunnlaget for det meste av det du vil lese i denne boken, ettersom det inneholder kode fra mine tidligere prosjekter, kode jeg har opprettet og lært å skrive metodisk for hånd, og et bredt spekter av ideer og tips som har hjulpet meg å lykkes med det punktet du kan se din venn eller familie som bruker Internett, til å se og oppføre deg som en populær app.

Hva denne boka er: Denne boken er en tutorial ved eksempel. Du kan finne kode her, instruksjoner for hvordan du kan lære å kode, informasjon om feilsøkingskode og fikse feil, feilsøking av trinn, instruksjoner om hvordan du kan sikkerhetskopiere og lagre koden din, distribuere hvis noen bryter koden din, sikre koden din, distribuere koden din, bygge interaktive nettsteder som er underholdende, engasjere, og du vil gjøre deg selv, og du vil få en sans for hvem jeg er, og du vil gjøre deg selv, og du vil gjøre deg selv, og du vil gjøre deg selv. Programvaren du bygger i det absolutt beste lyset for å være den mest attraktive som mulig for sluttbrukerne, nettstedets besøkende. I denne boken vil jeg demonstrere en rekke eksempler på programvaredesign med fokus på nettet som plattform så vel som sikkerhet. Vi vil sette i gang læringsopplevelsen ved å bygge et grunnleggende prosjekt ved hjelp av UNIX -skallet, med sikkerhetskopierings- og skriptfunksjoner. Deretter vil vi undersøke et grunnleggende bloggnettsted, oppgradere bloggen vår med foto- og videofunksjoner, samt bruke disse funksjonene til å bruke sikkerhetsløsninger ved hjelp av gratis programvare, og sikre serveren vår ved hjelp av en pluggable autentiseringsmodul (PAM). Vi vil deretter gjennomgå filhåndtering og prosessering, utforske videoredigering, stemmedonasjon, strekkodeskanning og optisk karaktergjenkjenning, blant andre konsepter. Underveis vil vi undersøke API -er som vil hjelpe oss å gjøre programvaren vår mer nyttig og sikker, med gratis og betalte alternativer. Underveis vil vi utforske fysisk sikkerhet og militante verktøy som skytevåpen og ammunisjonsdesign og produksjon, inkludert tønne og repeaterdesign, tårn og dronedesign, og andre rektorer vi vil integrere med programvaren vår i det eksisterende nettverket for å beskytte programvaren vår og demonstrere selvforsvar og spenst. Vi vil ta pauser underveis for å bygge spill, 2D- og 3D -gjengivelsesmotorer, og jobbe med innebygd maskinvare i casestudieeksempler på grunnleggende dimensjonal gjengivelsesprogramvare og en elektronisk vibrerende massørstøpt i henholdsvis silikongummi. Underveis vil vi også bruke maskinlæringsløsninger som allerede er tilgjengelige for å sikre programvaren vår bedre. Vi vil også bruke aksjeverktøy tilgjengelig for nettet for å effektivisere og sikre prosessen. Denne boken er en guide til din suksess med å bygge en webapplikasjon og integrere den med et profesjonelt nettverk av datamaskin og innebygde mekaniske systemer, og samlet sett en guide til å bygge programvare og innebygd maskinvare uten bakgrunnskunnskap eller tidligere erfaring.

Hva denne boka er ikke: Hvis du virkelig vil ha et nettsted, kan du bare sette opp en enkel butikk og selge det du trenger, legge ut en blogg, legge ut bilder eller videoer eller på annen måte uten å skrive en eneste kodeinje. Denne boken er ikke det. Denne boken vil lære deg hvordan du bygger programvare som er mer nyttig, fullt omtalt, funksjonelt og sikkert enn noen programvare du allerede kan finne, fordi den distribuerer den nyeste programvaren som fremdeles er prototyper, kan være dyrt å kjøre i en skala eldre selskaper som ikke opererer, og ikke appellerer til bakover, viklet selskaper som er satt opp for å tjene penger for folk som ikke virkelig gjør noe. Hvis du følger denne boken nøye, vil du skrive kode, forskningskode, bygge dine egne apper, og du vil tjene penger på det du gjør. Jeg vil tjene penger på denne boken, selv i tidlige stadier, fordi den inneholder informasjon folk trenger og vil lese, og allerede kjøper når de kjøper eller bruker appene mine. This book won't build an app for you, but it will point you in the right direction and arm you with the tools you need and the skills and tips that will facilitate your own success in building software for the web, with every line of code you will need to write as an example, ready to be pieced together into software you and your supporters, guests, clientele, friends, family, visitors, contractors, and the people of the internet want to use and support.

Hva du vil lære: Denne boken vil lære deg hvordan du bygger og selger programvare, virkelig funksjonell, nyttig programvare, medieopptak, sikkerhetsfunksjoner som ansiktsgjenkjenning, maskinlesbar sone strekkodeskanning, web -API -er for å autentisere, registrere og gjengi video og bilder, og utveksle meldinger som Bluetooth og nær felt (NFC) kommunikasjon. Denne boken vil lære deg hvordan du bruker en nettverksdatamaskin, med fokus på Debian Linux, hvordan du bygger bash -kode for å lage installasjon og sikkerhetskopiering av programvaren din til en sømløs, automatisert bris, hvordan du bygger Python -kode som en backend for å servere Dynamic -meldinger, stil ting som pent å bruke CSSS -styler med Bruker -applices gjennom nettverksbilder og interaktive til å få en t - Meldinger for verifisering eller andre formål, ID -skanning, bilde- og videomoderering, datamikrotransaksjoner for å holde programvaren din sikker, betalingsbehandling, cryptocurrency trading, asynkrone oppgaver og mer. Du lærer hvordan du bygger dine egne Bluetooth -enheter, med batterier, ladere, mikrokontrollere, kretsløp, motorer og sensorer, ved hjelp av lodde, ledning og 3D -trykt samt støpematerialer. Jeg vil demonstrere 3D -design rektorer brukt på additiv produksjon og verktøy og dø, slik at du kan produsere dine egne innebygde, maskinvareenheter med integrerte batterier, ladere, elektroniske kretsløp og funksjonelle utganger. og nettverk dem med Bluetooth og nettet. Spesifikt vil vi undersøke to casestudier, en vibrerende massasje og et hjemmelaget skytevåpen, begge programmert i OpenScad, som er tilgjengelig som et grafisk grensesnitt eller kommandolinjeverktøy og kan integreres i en nett for raskere resultater. Du lærer hvordan du bygger og distribuerer et nettsted fra grunnen av uten tidligere erfaring, gjør det funksjonelt, sikkert, vakkert, nyttig og viktigst praktisk. Du lærer hvordan du bruker maskinlæring og datamaskinvisjon for å gjøre et nettsted sikkert og mer praktisk, spille inn video og lyd fra nettstedet ditt, donere stemmen din, lage musikk og modulere lyd for å lage nyttige prøver, og hvordan du kan bryte gjennom støyen ved å utnytte andre nettsteder for å bygge et best mulig nettverk av nettsteder som du kan koble direkte til deg for å dele all den nyttige informasjonen du må tilby, og enda mer mer viktig viktig. Denne boken vil være fokusert mest på media, sikkerhet og maskinlæring, som er de viktigste tre komponentene som vil hjelpe deg med å bygge nyttig programvare for nettet ved å engasjere de rette brukerne og koble fra de gale på en måte som er realistisk, praktisk, hendene på og engasjerende mens de også er automatiske og solide. Denne boken lærer UNIX, spesielt Debian (Ubuntu), Bash Shell, Python, HTML, CSS, JavaScript og en rekke nyttige programvarepakker for Python som forespørsler, samt nyttig bash -programvare som GIT og FFMPEG. Jeg vil også lære deg hvordan du kan handle cryptocurrency automatisk, og ta betalinger i cryptocurrency eller fra vanlige debetkort, mens du til og med betaler ut besøkende en andel av inntektene dine hvis du velger å gjøre det. Jeg vil lære deg hvordan du også kan tjene penger på nettstedet ditt gjennom reklame, hvordan du kan klargjøre appen din for søkemotorer og gjøre den raskt, rangert i første rangering for hva kundene dine vil søke etter å finne deg, og rangere i så mange vanlige søk som mulig. Jeg vil lære deg hvordan du selger programvaren din, annonserer den, appellerer til kunder som leter etter tjenestene dine og lager et navn for deg selv på internett gjennom veier som allerede eksisterer, er rimelige og fungerer bra. Jeg vil lære deg hvordan du kan lagre dataene dine på skydatamaskiner som fungerer for deg og lagre dataene dine billig, hvordan du planlegger og bygger et nettsted som gjør det brukerne dine vil ha og hva du vil, og hvordan du kan holde brukerne dine engasjert ved å legge nettstedet ditt et trykk på telefonene dine med varsler, e -post, tekstmeldinger, telefonsamtaler og mer veenues for å bringe brukerne dine. Denne boken vil fokusere på det praktiske ved å publisere og distribuere medier i store mengder, fra tekst til bilder til videoer til lyd, gjøre et godt inntrykk på sluttbrukere (klientellet ditt) og selge deg selv på noen måte som du gjør for å lage et nettsted, en app som er representativ for deg og deg bare, og gjør deg, programvaren din og selskapet ditt ser bra ut på den beste måten. Du vil også lære noen tips og triks fra meg, fra kodingstips, praktisk forfengelighet som sminke og fotografering, modellering og skuespill, og mer, noe som vil være viktig for å skildre deg selv og ditt selskap i best mulig lys ved å bruke alle verktøyene som er tilgjengelige for deg mens du distribuerer så mye innhold som du trenger på tvers av en sunn balanse. Denne boken heter "PRAKTISKNettbasert dyp læring og sikkerhet ved eksempel "av en grunn: den omhandler læring å kode, spesielt for nettet, spesielt med fokus på sikkerhet, fra et praktisk synspunkt, med eksempler på arbeidskode som tjener de praktiske formålene som er skissert i teksten. Læringskomponenten i denne teksten som også skal håndtere maskinlæring, koden jeg vil vise deg hvordan du skal kjøre for nettet som vil håndtere datamaskinvisjonen visjon. Forbedring, billedtekst og andre oppgaver som prediksjonsmålinger hentet fra bilder, for eksempel arten av bildet som et autentisk, datamaskinoverført bilde, eller en optisk kopi (et bilde av et bilde, eller trykt bilde). Du med ansiktet ditt. du bruker). Alle som bygger programvare som er upåklagelig sikker, har en viss følelse av hva dette innebærer. Programvare er iboende usikker fordi enhetene og kontoene vi bruker for å få tilgang til den ikke alltid er til disposisjon, de kan være i hendene på alle med dårlig hensikt for programvaren og kan derfor utgjøre en risiko for selve programvaren. Dette er noe av fokuset i denne boken. En nettverksdatamaskin er som standard sikret med en lang nøkkeltoken, kalt og SSH eller Secure Shell -tasten, og er ellers best sikret med en webserver, fordi webserveren gir åpen tilgang så vel som topp moderne sikkerhetsverktøy som kjører på selve serveren. Webserveren har tilgang til brukerens nettleser, som uten tvil er den kraftigste delen av brukerens enhet, fordi det er stedet der brukeren kan få tilgang til nettverksprogramvare. Dette verktøysettet kan gi tekst, websidene du ser, og kan også spille inn bilder, lyd og video (som et bilde av et ansikt eller en tilstands -ID), kan lese og skrive til Bluetooth Radio -enheter, og kan lese og skrive til nærmere felttransponder -tagger, rimelige nøkkelkort, fobs, klistremerker, ringer og til og med en brikke med unike nettverk som kan være lest og ringer og til og med en gyldige tagger med en lest for å Ved å bruke alle verktøyene du har til rådighet, vil du med denne boken utstyre deg med kunnskapen til å bygge et sikkert nettsted, og samlet sett et sikkert nettverks datasystem som fungerer for deg, gjør din bud og ser og føles

Hvor du skal begynne: Du er velkommen til å hoppe forbi seksjonen jeg begynner denne boken med, eller en hvilken som helst seksjon, til den nøyaktige koden du trenger, spesielt hvis du har erfaring med koding før eller noen av de nevnte verktøyene jeg vil beskrive i detalj i denne boken, samt dokumentere brukssaker og praktiske eksempler derav. Hvis du ikke har erfaring med å skrive kode, anbefaler jeg at du leser all denne boken, og anbefaler spesielt at du leser de foregående seksjonene, for å sikre at denne boken passer for deg. Hvis denne boka ikke er riktig for deg, kan du vurdere å gi den til en venn eller slektning som kan være interessert i å lære om nettutvikling selv, og til og med vurdere å låne den tilbake og lære av dem for å fylle ut hullene der jeg sviktet deg som lærer, eller andre lærere gjorde før meg. Start hvor du vil, vil hver del av denne boken være nyttig hvis du har tenkt å bygge en nyttig app, og vurder at de beste appene er bygget med sluttbrukeren i tankene: Kjenn kunden din. Nå kjenner du meg, du kjenner denne boken, og du er klar til å begynne. For å starte, ta en datamaskin (til og med den billigste bærbare datamaskinen fra en boksebutikk, Amazon eller et gammelt stasjonær fungerer, og sett den opp på en måte som fungerer for deg.

Hvordan lese denne boken: Tekst fremhevet, betegner at teksten tilhører en ledetekst, der du vil skrive koden du kjører. Kommandoprompet er tungt tastaturfokusert og krever lite eller ingen klikking, fremskynder arbeidsflyten og gjør ting enklere for deg.

Komme i gang: La oss dykke inn. Vi starter med å bygge kode på en lokal maskin og begynne uten å bygge et nettsted koblet til Internett. Dette er tryggere til å begynne med, koster ingenting og er lett for deg. Avhengig av operativsystemet ditt, vil det være litt annerledes å komme inn i et bashell. For Mac OS anbefaler jeg å installere en virtuell maskin på dette tidspunktet, da du vil få mest kompatibilitet med en virtuell maskin. Ulike leverandører som VirtualBox og Paralells kan kjøre en virtuell maskin for deg, selv om det også er mulig å installere Ubuntu direkte på maskinen, hvis du foretrekker å bruke et innfødt miljø som anbefales for å skape en rask, strømlinjeformet opplevelse. Hvis du bruker Linux eller Windows, som jeg anbefaler, skal det være ganske enkelt å lage et prosjekt. Åpne terminalen, juster størrelsen slik du ser passet, og begynn å følge trinn 2. Hvis du bruker Windows, kan du følge trinn 1.

Trinn 1: - Bare Windows -brukere I Windows, Open Command -ledeteksten som administrator og type WSL –Install

Trinn 2: - Fortsett her, eller hopp over trinn 1 til her hvis du ikke bruker Windows I en åpen terminal, (avhengig av OS, kalt Ubuntu i Windows, Terminal i Mac eller Linux, eller et lignende navn), begynner du med å lage et prosjekt. Vi gjør dette med mkdir -kommandoen, som oppretter en katalog. Hvis du trenger å opprette en katalog for å lagre prosjektet ditt, som anbefales, bruker du CD -kommandoen for å endre til katalogen og og og

CD/PATH/TO/DIRECTORY - The Path er mappene (filene) som går foran din destinasjonskatalog, din standardbane er ~ eller/Home/Brukernavn (der brukernavn er ditt brukernavn). For å endre til standardkatalogen, skriv CD eller CD ~ mkdir eksempel - erstatt "eksempel" med navnet på katalogen

Nå har du en arbeidskatalog for prosjektet ditt. Som det er så viktig å få denne katalogen lagret i tilfelle du trenger å bytte til en annen maskin eller distribuere koden du skriver, så den er klar for nettet, vil vi bygge et skript for å sikkerhetskopiere katalogen din i de neste trinnene. Men å bygge et skript tar litt kode, og kode må automatiseres for å være så nyttig som mulig. Så la oss bygge et manus for å bygge skript først. La oss starte med å lage skriptet og gjøre det kjøres. Vi bruker sudo, chmod og berøring for dette, og kaller skriptet "ascript".

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

Nå har vi laget skriptet, gjort det kjøres og er klare til å redigere det. Nano er en tekstredigerer som lar deg redigere tekst uten å klikke, noe som er mye enklere enn å bruke et grafisk brukergrensesnitt. For å redigere en fil med Nano, bruk Nano og deretter banen til filen. For å lage et skript som lager et skript, er det ganske likt å lage skriptet vårt i utgangspunktet. Vi bruker den samme koden som ovenfor, og erstatter navnet på skriptet, "Ascript" med en argumentparameter, $ 1. Dette lar oss ringe skriptet ved å skrive ganske enkelt Sudo Ascript Newscript, på hvilket tidspunkt vi kan lage et nytt skript ved å erstatte "Newscript" med navnet på skriptet ditt. Koden i Nano skal se ut:

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

Og for å lukke Nano, kan vi holde ned kontrollnøkkelen og trykke X, deretter Y for å betegne at vi lagrer filen og treffer retur. I stedet for å skrive disse tre kommandoene for å redigere et skript, vil vi kunne skrive Sudo Ascript Ascript for å redigere skriptet igjen. Dette fungerer! Og ethvert nytt skript kan kjøres enkelt ved å ringe det i skallet. La oss lagre arbeidet vårt nå: La oss skrive et sikkerhetskopieringsskript for å lagre det nye skriptet vårt og deretter sikkerhetskopiere det i prosjektkatalogen vår, samtidig som vi sikkerhetskopierer backup -skriptet.

sudo ascript backup

Nå, i Nano:

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

Hvor/bane/til/katalog er veien til prosjektet du opprettet med MKDIR. Senere vil vi lære å kopiere gjentatte stier som denne med en sløyfe og en liste, som er mindre kode, men foreløpig la oss holde det enkelt og ha noen få linjer. For å kjøre dette skriptet og sikkerhetskopiere koden din, lagre filen i Nano med kontroll+x, y og returnerer, og skriv nedenfor i skallet ditt

backup

Hvis du i det hele tatt blir bedt om et passord mens du leser denne boken og følger med i skallet, vennligst skriv inn brukerpassordet ditt riktig, vil du ha tre forsøk før du trenger å kjøre kommandoen på nytt. Du kan bruke pilene opp og ned til å kjøre kommandoer og redigere dem, hvis du trenger å kjøre noe to ganger. Enkelt trykk opp og ned av og ned for å velge en kommando, før du redigerer kommandoen med høyre, venstre piler og slett tast så vel som tastatur, og kjører den med retur.

Gratulerer! Du klarte å lage et fantastisk sikkerhetskopieringsskript som sikkerhetskopierer to viktige skallskript i arbeidskatalogen din. Vi kan flytte ting rundt senere etter hvert som prosjektet blir større, men dette fungerer for nå. La oss gå videre til å sikkerhetskopiere i skyen, vi bruker GitHub til dette (selv om det er mange andre Git -løsninger for sikkerhetskopi, de handler om det samme.) Git er en Verision Control -programvare som lar deg sikkerhetskopiere redigeringer til programvaren din når du gjør dem til en server, samtidig som du lar deg laste ned hele kopier av programvaren din bak et passord eller nøkkel. Det er medvirkende til å lagre programvaren din, spesielt når vi migrerer til sikrede Linux -forekomster som noen ganger går i stykker når en enkelt kodelinje mislykkes, og lar deg være låst ut mens koden din kanskje ikke blir sikkerhetskopiert hvis du ikke får sjansen til å sikkerhetskopiere den automatisk, som vi vil dekke.

Hvis du ikke allerede bruker en virtuell Ubuntu på dette tidspunktet, anbefaler jeg å bruke en Ubuntu Virtual Machine på dette tidspunktet fordi det vil gjøre livet ditt enklere når du installerer alle pakkene som er nødvendige for å bygge et fungerende nettsted og forhåndsformere dype læringsoperasjoner på datamaskinen din. Vi vil flytte koden til en webserver i løpet av en nær fremtid, men vi vil sørge for at det er minst noen få lag med sikkerhet bak webserveren vår som er motstandsdyktige mot phishing, og bruker en rekke Linux -pakker for å gjøre dette. Hvis du fremdeles vil bruke Mac OS, er du velkommen til å søke etter og installere de nødvendige pakkene på nettet, men det er kanskje ikke alternativer for hver pakke denne boken eller serien vil dekke.

La oss legge til noen få kommandoer for å begå vårt arbeid med sikkerhetskopieringsskriptet ved å kjøre kommandoen Sudo Ascript -sikkerhetskopi.

# ...

Nok en gang kan du kontrollere X for å lagre.

Nå må vi gjøre en engangskonfigurasjon for dette prosjektet. Fordi det snart vil være et Git -prosjekt, trenger vi ikke å skrive hver kommando hver gang vi distribuerer fra et Git -depot, men vi får tak i dette når vi skriver distribusjonsskriptene våre. For å starte, la oss sørge for at vi er i riktig katalog og initialiserer Git -depotet og genererer SSH -tastene.

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

Etter at vi har skrevet SSH-KeyGen, bør den nye tasten lagres i hjemmemappen under en mappe kalt .SSH. Det kalles id_rsa.pub. La oss finne denne nøkkelen og kopiere den. Å se det,

cd ~
cat .ssh/id_rsa.pub

Kopier teksten som returneres av den siste kommandoen, og opprett en konto med din GIT -leverandør (ideelt GitHub), før du legger til SSH -tasten til kontoen din. Når du har en konto, klikker du på den øverste høyre menyen og angir innstillinger, før du legger til SSH -tasten i SSH- og GPG -tastene under tilgang i menyen. Velg Legg til en SSH -tast og legg til din ved å lime den inn og gi den en tittel, før du lagrer og går tilbake til Github for å opprette et nytt depot. Dette er likt for andre GIT -leverandører, du må lese dokumentasjonen deres. I den nye depotkonfigurasjonen, gi depotet ditt et beskrivende navn og bestemme om du vil publisere det, og sørg for å konfigurere ingen filer for inkludering ennå. Når depotet er opprettet, kopierer du klonen med SSH URL, og lim den inn i følgende kommando.

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

Nå kan du flytte tilbake til depotet ditt med CD, du vil være kjent med dette. Prøv sikkerhetskopieringsskriptet ditt nå med sikkerhetskopi

Stor! Nå kan vi virkelig få koding. La oss installere Django nå som vi har et godt grep om bash og git. Django vil la oss automatisk sikkerhetskopiere programvaren vår, Bash kan gjøre dette også, men Django bør ha en enklere tryggere implementering (den kan deaktiveres og konfigureres lettere).

For å installere programvare i Ubuntu, bruker vi Sudo Apt-Fet-kommandoen. La oss først oppdatere og oppgradere programvaren vi allerede hadde. Dette kan gjøres med sudo apt-get update og sudo apt-get oppgradering -y. Neste, la oss installere Python og vårt virtuelle miljø, hjemmet til koden vår, med følgende kommando: sudo apt-get installere python-er-python3 python3-venv

Dette er alt du trenger for å komme i gang med Django når det gjelder programvareinstallasjoner i Ubuntu -forekomsten. For Windows og Linux skal dette være ganske greit, men for Mac kan det være lurt å installere en virtuell maskin og Linux på den ved hjelp av et gratis eller betalt virtuelt miljø som VirtualBox eller Paralells Desktop og gjenskape trinnene over for å sette opp et Ubuntu -miljø. Ubuntu er kritisk i dette tilfellet fordi det er programvaren nettstedene kjører og det gjør dem i stand til å være vert for nettsteder med all den nevnte programvaren.

La oss grave i Django.

I katalogen vår igjen, med CD:

python -m venv venv # Oppretter det virtuelle miljøet der kode lagres
source venv/bin/activate # Aktiverer det virtuelle miljøet
django-admin startproject mysite . # Hvor min plass er prosjektet jeg begynner i min nåværende katalog.

Django er bare i gang, fordi Django er vert for webserveren og gjør alt vi trenger for å få et grunnleggende lokalt nettsted i gang. Nå som vi har Django installert, la oss redigere innstillingene litt for å få det til å fungere hvordan vi trenger. La oss først lage en ny app

python manage.py startapp feed

Du vil merke at den første appen heter Feed. Appen skal kalles hva du vil, og vi oppretter nye apper, men navnet på hver app må være konsistent hver gang appen blir referert til i koden. For å legge til en ny app, vil vi alltid redigere innstillingene. Bruker nano,

nano app/settings.py

I innstillingene, finn installerte_apps og skill [] i 3 linjer. Bruk fire mellomrom på den tomme midtlinjen, legg til 'feed', eller navnet på appen din. Denne delen av innstillingene. Py skal se ut som:

INSTALLED_APPS = [
    'feed',
]

Før vi glemmer, la oss teste at Django fungerer. Ved å bruke kommandoen python administrer.py runserver 0.0.0.0:8000, kan vi kjøre serveren og deretter navigere i en nettleser på datamaskinen som kjører koden til http: // localhost: 8000 og se et eksempel på websiden (den fungerer!) Avslutt serveren med Control C, det samme som enhver annen kommando.

La oss nå grave i å skrive noen Python -kode. Django har tre hovedkomponenter, alle kjøres helt etter kode. Komponentene kalles modell, visning og mal, og hver er på henholdsvis et høyere og lavere nivå før websiden blir levert til brukeren.

Modellen er koden som lagrer informasjon i databasen for henting, sortering og gjengivelse.

Visningen bestemmer hvordan modellen blir gjengitt, manipulert og modifisert, nesten alle visninger vil bruke en modell direkte.

Malen er HTML -koden med noen ekstra bjeller og fløyter som kalles malspråk. Malen er gjengitt av visningen der den er fylt med Python -kode og kontekst som modeller og informasjon (Usuall -strenger og heltall) fra visningen.

Django har andre komponenter også, inkludert, men ikke begrenset til:

Innstillinger, som konfigurerer appen som vi diskuterte.

URL -er, som er mønstre som brukeren følger for å få tilgang til spesifikke deler av webapplikasjonen.

Skjemaer, som definerer hvordan informasjon som sendes til serveren håndteres og gjengis til databasen så vel som til brukeren. Dette er grunnlaget for å behandle informasjon på serversiden, og kan godta enhver form for informasjon datamaskinbutikkene, spesielt tekststrenger, tall og sanne/falske booleanere (vanligvis avkrysningsruter).

Maler, som er HTML -kode og malspråk og broer gapet mellom Python og HTML, noe som betyr at Python -informasjon kan serveres som HTML -kode som alle kan få tilgang til og kan sikre et nettsted med begrenset tilgang, mens du gjør Python -kode tilgjengelig på nettet og nyttig for en rekke formål på en fjern enhet som ikke trenger å være nær serveren.

Statiske filer, som vanligvis er JavaScript og det er biblioteker som serveren serverer og er koblet inn med malen.

Mediefiler, som serveren serverer eller er eksternt vert, eller nettopp skrevet til serveren før den blir behandlet og lagt ut til en annen server (en bøtte) for hosting.

Middleware, som er kodebiter som kjøres samtidig som alle syner og blir vurdert "inkludert" i visningen.

Kontekstprosessorer, som behandler konteksten til hvert syn og brukes til å legge til ekstra kontekst.

Tester, som validerer at brukeren eller forespørselen vedtar visse krav før visningen er gjengitt.

Forbrukere, som dikterer hvordan websockets håndterer og reagerer på kommunikasjon.

Administrator, som brukes til å registrere modeller slik at de kan manipuleres i detalj på Django Admin -siden, der databasen kan administreres gjennom et grafisk grensesnitt.

Selleri, som definerer asynkrone oppgaver deler av Django -koden kan begynne å løpe før de umiddelbart fortsetter til neste oppgave eller kodelinje.

Django kan ha mange andre komponenter, som vi vil diskutere i detalj her. Det er mange måter å gjøre Django mer funksjonelle, og legge til websockets, som er raske, strømlinjeformede kommunikasjonskanaler, selleri, som utfører asynkrone oppgaver og et mangfold av andre programvare for å utvide Django, spesielt i visningsfunksjonene, der det meste av koden er utført. Visningsfunksjoner er nøkkelen fordi de vanligvis erklærer hvert kode som er spesifikt for et spesifikt URL -mønster, eller en del av serveren.

La oss først utforske visningsfunksjoner. Vis funksjoner begynner med import som betegner kode som vil bli brukt i visningen, og er definert ved hjelp av vanlige funksjonsdefinisjoner eller klasser. De enkleste visningene er definert av funksjonsdefinisjonen DEF, og returnerer en HttpResponse med en grunnleggende mal. La oss starte med å definere et grunnleggende visning for å returnere teksten "Hello World". Husk at hver gang du legger til kode etter en uttalelse som DEF, hvis du, for osv., Må du legge til 4 mellomrom for hver av de foregående definisjonene du ønsker å bruke på funksjonen din. Vi vil komme inn på hva hver av disse snart betyr.

Fra nettstedets katalog, rediger Feed/Views.py -filen ved å bruke Nano og legge til følgende linjer til slutten av filen.

from django.http import HttpResponse

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

Djangos HttpResponse svarer med en tekststreng, betegnet med åpningen og lukkingen. Hver gang du gir informasjon til en funksjon eller klasse, som forespørsel eller en streng, må du bruke parentes (, åpning og lukking).

Dette er ikke alt vi trenger for å se vårt syn ennå. Vi har selvfølgelig ikke fortalt serveren hvor visningen er nøyaktig, vi må fortsatt definere en bane som visningen skal gjengi. La oss starte med å definere en grunnleggende vei i app/urls.py, og vi kommer inn i banegrupper senere.

I app/urls.py, legg til en linje etter importuttalelsene etter at begynnelsen har importert visningen vi nettopp opprettet.

from feed import views as feed_views

La oss nå definere visningsmønsteret. Vismønstre har tre komponenter, banekomponenten, som forteller serveren hvor visningen eksisterer på serveren (URL -banen som brukeren skriver inn i navigasjonslinjen for å gå inn i websiden), visningskomponenten der visningen er, og et vennlig navn for visningen kan endres. Det er fornuftig å gjøre ting på denne måten og være fleksibel, fordi kodebasen din vil være et stadig skiftende miljø som trenger fleksibilitet og improvisasjon for å være verdifull og enkel å jobbe med. Slik vil synet ditt se ut, du kan legge dette til UrlPatterns = [delen av appen/urls.py. Visemønsteret er definert med de tre komponentene beskrevet ovenfor, og en funksjon som kalles bane. URL -mønstrene dine er en liste, så sørg for alltid å avslutte hvert element i dem med komma, fordi dette skiller hver enkelt. Hvert element skal også gå på en ny linje, nok en gang med fire mellomrom før den, akkurat som appen i innstillinger. Vi vil definere den første komponenten i visningen med en tom strengfunksjon, for å lage en visning som kjører på rotkatalogen til webserveren. Nettadressene dine skal nå se slik ut:

from feed import views as feed_views

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

Dette er grunnlaget for å opprette et nettsted med Django som er helt statisk. For å lage et mer dynamisk nettsted der vi kan begynne cacheinformasjon, som bilder, videoer, lyd og mer, må vi bruke modeller, som vi vil utforske neste gang. Foreløpig, la oss sjekke koden vår og kjøre serveren. For å sjekke koden for feil, kjør: Kjør:

python manage.py check

Hvis det er noen feilmeldinger, bør du nøye gjennomgå endringene du har gjort i appen din og se om det er noe som må løses, som et utenom eller manglende rom, en ekstra karakter, en ikke -lukkede streng, hvilken som helst skrivefeil, ethvert ved et uhell slettet tegn eller noe annet. Les gjennom feilmeldingen (hvis du har en), bør du kunne se banen til en fil du opprettet eller redigert sammen med et linjenummer, så se på den filen og linjen og se om du kan fikse noe som er der. Hvis du har løst problemet, kjør kommandoen ovenfor igjen. Når programvaren din er klar til å kjøre og fungerer, vil du se utdata -systemkontrollen identifisert ingen problemer. " Nå er du klar til å dra. Kjør serveren med:

python manage.py runserver 0.0.0.0:8000

Nå åpner du en nettleser og navigerer til http: // localhost: 8000. Du bør se teksten som returneres i parentesen og sitater av HttpResponse -funksjonen etter ditt syn. Dette er bare et grunnleggende eksempel, men hvis du klarte det så langt, forstår du det grunnleggende om hvordan Linux, Bash, Python og Django fungerer. La oss grave dypere i noen databasemodellering, og utforske kraften til en Python -klasse når det gjelder lagring av informasjon. Deretter vil vi begynne å få tak i HTML og CSS før vi gjør nettstedet vårt fullt omtalt, fleksibelt og sikkert ved hjelp av JavaScript og maskinlæring.

Klassene lagres i modellene. Bruk Nano, rediger app/modeller.py og legg til en ny klasse. En klasse er definert med klassedefinisjonen og sendes en superklasse som den arver fra, i dette tilfellet modeller. Modell. Navnet på klassen kommer etter klassedefinisjonen, og etter klassedefinisjonen A: (tykktarm) er brukt, før attributtene og funksjonsdefinisjonene knyttet til klassen er betegnet nedenfor. Klassen vår trenger en ID vi kan bruke for å hente den og holde den unik, og den trenger også et tekstfelt for å lagre litt informasjon. Senere kan vi legge til en tidsstempel, filer, booleanere (sanne eller falske definisjoner som kan hjelpe koden vår med å ta beslutninger om hva vi skal gjøre med modellen, og kan brukes til å sortere den), en forekomst for å knytte modellen til en bruker som er logget inn på serveren og mer. La oss pakke ut koden nedenfor:

from django.db import models # Importen som brukes til å definere klassen vår og den er attributter
class Post(models.Model): # Definisjonen av klassen vår selv
    id = models.AutoField(primary_key=True) # IDen til modellen vår, en automatisk generert nøkkel som lar oss spørre modellen, holde den unik og er nyttig når vi trenger å samhandle med modellen når den er opprettet.
    text = models.TextField(default='') # Attributtet våre klassebutikker, i dette tilfellet, noen tekst, som misligholder en tom streng.

Lukk og lagre filen som vi gjorde før for å fullføre.

Det er mange andre felt og alternativer vi vil utforske når vi oppdaterer denne klassen når appen vår utvikler seg, men dette er de grunnleggende nødvendighetene ved å lage en app for å legge ut litt tekst. Imidlertid vil denne modellen ikke fungere alene. Som beskrevet tidligere, trenger vi en tilpasset visning og tilpasset URL -mønster for å få denne modellen til å fungere, og vi trenger også et skjema sammen med en mal. La oss utforske skjemaet først.

For å definere et skjema, rediger APP/Forms.py med Nano og legg til følgende linjer. Vi trenger to importer, vår skjema -klasse, så vel som modellen vi opprettet (Feed.Models.post), en klassedefinisjon som ligner på modellen, og et felt sammen med en underklasse kalt Meta som vil definere modellen formen samhandler med. Skjemaet kan også ha en initialiseringsfunksjon som setter den opp basert på informasjon i forespørselen, modellen eller på annen måte, vi vil utforske dette senere.

Modellformer er så nyttige fordi de kan lage en modell eller også redigere en modell, så vi vil bruke dem til begge. La oss definere en i Forms.py nedenfor.

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

Dette er det grunnleggende om hvordan en form og modell ser ut. Denne modellskjemaet kan brukes til å instantisere eller redigere et innlegg, og endre teksten den inneholder. Vi ser på å integrere dette skjemaet i en visning neste. La oss først gjøre migrasjonene og migrere databasen slik at koden vår kan samhandle med modellen når den kjører. For å gjøre dette, kjør følgende kommandoer:

python manage.py makemigrations
python manage.py migrate

Dette vil ta et øyeblikk å utføre, men når det gjør det, vil det gi deg tilgang til modellen i visningene, mellomvaren eller hvor som helst ellers i programvaren. La oss fortsette med å gjøre et syn der vi kan se modellen vår. Rediger feed/views.py og legg til følgende kode, som nevnt. Du trenger ikke å legge til noe etter # tegnet, den koden er kommentarer som brukes til å betegne informasjon om koden. Vi starter med å importere modellen vår i visningene, og legge den til en kontekst der vi kan gjengi den i en mal som en liste for visning. Deretter vil vi legge til en mal der vi kan gjengi skjemaet og modellen med en knapp for å opprette et nytt objekt basert på modellen og legge den ut på serveren. Dette høres komplisert ut, så la oss bare ta det trinn for trinn. Før vi er ferdig med visningen, la oss lage en mal som bare gjengir modellen og sørger for at vi kan se den ved å lage et nytt innlegg i skallet. Slik skal den visningen se ut:

    posts = Post.objects.all() # Spør alle innleggene i databasen så langt

Alt dette ser ganske enkelt ut til vi kommer til bunns. Render, verdien som returneres av funksjonen i stedet for i et HTTP -svar som det forrige eksemplet, tar alltid en forespørsel som den første inngangen, godtar en kontekst (i dette tilfellet innleggene i databasen), som nå kan gjengis i malen, og returnerer malen som er definert i funksjonen. Malen kommer til å være et HTML -dokument med litt av et språk som heter Jinja2, som gjør Python -informasjon til HTML.

For å begynne å lage maler, lag to kataloger i feed.

mkdir feed/templates
mkdir feed/templates/feed

Deretter redigerer du en mal i katalogen ovenfor, feed/maler/feed, og legg til koden for dette eksemplet. La oss se på malen for dette eksemplet.

Dette er en veldig enkel mal. Den definerer åpning og lukking av HTML -tagger, en dokumenttype -tag, en kroppskode med en legendtittel, en pausemag som legger til en liten linje over skjermen, og en for loop som gjengir hvert innlegg i listen over innlegg som et avsnitt i malen. Dette er alt som trengs for å gjengi innlegg, men det er ingen i databasen ennå. La oss lage noen med skallet. Vi kan kjøre skallet med Manage.py

python manage.py shell

La oss nå importere innleggsmodellen vår

from feed.models import Post

Deretter lager vi et enkelt innlegg med en streng og avslutter skallet. Strengen kan være hva som helst, så lenge det er gyldig tekst.

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

Til slutt må vi legge til et URL -mønster i feeden vår. Fordi feed -appen vår vil bruke flere nettadresser og vi ønsker å holde filstørrelser små, la oss lage en lokal nettadresser i fôrappen vår som ser slik ut:

from django.urls import path
from . import views

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

Vi må også redigere nettadressene i basen, uansett hva vi bestemte oss for å kalle det, dette var den første katalogen vi opprettet. Rediger app/app.py og legg til følgende i URL -mønstrene

from django.urls import include # øverst
    # ... Forrige kode her

Når vi kjører serveren med Python Administrer.py Runserver, vil vi se siden vi opprettet fordi vi har modell, visning og mal samt URL -mønster, sammen med elementer i databasen. La oss deretter implementere skjemaet vi opprettet og begynne å lage våre egne innlegg. Men før vi skriver for mye kode, la oss lage en sikkerhetskopi ved hjelp av skriptet vi skrev tidligere, sikkerhetskopiering. Kjør dette skriptet i skallet, vent noen få øyeblikk, og all koden vil bli sikkerhetskopiert til Git -depotet vårt.

backup

Å implementere skjemaet er relativt enkelt. Vi vil importere skjemaet vårt, legge til en postforespørsel til visningen og lagre innlegget i databasen før vi omdirigerer til samme visning. Vi kan bruke viderekoblingsfunksjonen vi allerede importerte, og en annen funksjon som heter Reverse for å få URL -en for visningsmønsteret. Vi spør om dette med strengen 'Feed: Feed' fordi navneområdet til det inkluderte mønsteret er fôr, og utsikten kalles også fôr.

    posts = Post.objects.all() # Spør alle innleggene i databasen så langt
    if request.method == 'POST': # Håndtere innleggsforespørselen
        form = PostForm(request.POST) # Opprett en forekomst av skjemaet og lagre dataene i det
        if form.is_valid(): # Valider skjemaet
            form.save() # Lagre det nye objektet
        return redirect(reverse('feed:feed')) # Omdirigere til den samme URLen med en get -forespørsel
        'form': PostForm(), # Sørg for å gi skjemaet inn i konteksten slik at vi kan gjengi den.

Nå må vi oppdatere malen for å gjøre rede for det nye skjemaet. Vi kan gjøre dette ved å bruke

La oss bryte dette ned. Det er en ny formklasse, et symbol, selve skjemaet og en innsendingsknapp. Ganske enkelt, men når vi ser på det, kan det være lurt å få det til å se bedre ut. Det fungerer, vi kan legge ut nye innlegg med skjemaet, og de er nå lagret i databasen. Det er noen få ting som skjer her. Vi bruker HTML -tagger for å erklære at dokumentet er et HTML -dokument, vi bruker en malkode ({ % ... %}) for å gjengi token for skjemaet, og en annen, {{…}} for å gjengi skjemaet. Vi har også en løkke for å gjengi teksten ved hjelp av blokkmerker og en malkode. Blokkmerker er veldig viktige fordi vi kan definere hvordan seksjoner av malen blir gjengitt med dem, og malmerker er grunnlaget for hvordan vi legger variabler i koden vår.

Nå må vi få appen til å se bedre ut, for nå ser den veldig grunnleggende ut. Vi kan gjøre dette ved å bruke CSS, enten inline, eller i klasser knyttet til hvert objekt i dokumentet. CSS er veldig fint fordi det forteller alt på siden hvordan det skal se ut, og kan få det til å se veldig bra ut. Det er noen få biblioteker som kan gjøre dette, men min personlige går til er Bootstrap.

Bootstrap kan lastes ned fra nettstedet deres,getbootstrap.com/. Når du er der, trykk på knappen for å lese installasjonsdokumentene, og kopiere koden fra Include via CDN -delen. Du trenger denne koden øverst i HTML -dokumentet ditt, i et kode som heter Head. La oss også gå foran og opprette en base mal slik at vi ikke trenger å gjenskape disse koblingene i hver mal.

Lag en ny katalog som heter maler med MKDIR -maler, og rediger deretter maler/base.html.

Det skal se slik ut:

Sørg for å kopiere CSS og JavaScript, .css- og .js -filene, fordi vi trenger JavaScript for å gjøre nettstedet vårt mer funksjonelt i fremtiden.

La oss nå komme tilbake til bashskallet og kjøre en rask kommando. Husk at hvis du noen gang trenger tilgang til det virtuelle miljøet, skriver du kilden VENV/BIN/Aktiver. Dette lar deg installere Python -pakker lokalt på en måte som lar Django få tilgang til dem. For å gi våre skjemaer generert av Django Bootstrap -klasser, vil vi bruke en Python -pakke kalt Crispy Forms. Vi kan laste ned dette med følgende kommando

pip install django-crispy-forms

Når dette er installert, kan du legge den til innstillingene.

    # ... Forrige kode her

Nå, tilbake i feedmalen vår, kan vi fjerne noen ting. La oss fjerne begynnelsen og slutten av dokumentet og erstatte det med arv fra basismalen vår, ved hjelp av utvidelse og blokkeringsdefinisjonen. Vi vil også legge til en malfilterimport med belastning og et malfilter til skjemaet. Til slutt, la oss legge til en bootstrap -klasse i knappen på skjemaet for å få den til å se mer ut som en knapp. Det skal se slik ut:

Vakker! Det er ganske mye kode allerede. Deretter bør vi teste det ut og sørge for at vi kan se at alt ser fint ut, og også være sikker på at alt fungerer som det skal. Kjør serveren i henhold til tidligere instruksjoner og sørg for at nettstedet ser ut og fungerer i orden. Flott jobb! Du er klar til å gå videre til neste trinn, der vi vil legge til brukerpåloggingsfunksjonalitet ved å bruke lignende nettadresser, skjemaer, visninger og maler. Basismalen er viktig, og vi vil fortsette å endre den og gjøre endringer etter behov, men foreløpig la oss fokusere på å gjøre nettstedet vårt sikrere, ved å gjøre det mulig for brukere å logge på med et brukernavn og passord, og til slutt enda viktigere informasjon som vil bidra til å holde appen din sikker og din egen konto bare tilgjengelig av deg.

For å gjøre dette, må vi bruke brukermodellen innebygd i Django. Brukermodellen er en databasemodell, som vårt innlegg, som kan gjengis for å logge en bruker på nettstedet. I fremtiden, før vi distribuerer nettstedet til Internett, vil vi utvide denne modellen med andre modeller som tilskrives det, og bygge ytterligere sikkerhetstiltak for innloggingen som er motstandsdyktige mot phishing. Vi begynner med å bruke noen innebygde påloggingsformer som Django gir. La oss først opprette en ny app som vi vil bruke for å gjengi malene og visningene for den grunnleggende påloggingssiden. Vi vil også lage andre apper for å representere de fortsatte påloggingsutfordringene for å sikre appen, inkludert en Pincode, ansiktsgjenkjenning, nær feltkommunikasjon, eksterne enheter, multi -faktorautentisering og fingeravtrykkgjenkjenning.

Vi snakket allerede om å starte en app. Fra katalogen vår, i det virtuelle miljøet, passerer

python manage.py startapp users

Nå skal vi ha en katalog for den nye appen. La oss starte med å lage en visning i den katalogen som tilsvarer brukerpålogging. Django har innebygd visninger for brukerpålogginger, men disse vil ikke være egnet for oss fordi vi trenger en tilpasset visning, noe som helst gjøres med en definisjon.

I denne visningen vil vi starte med å se etter en etterforespørsel, passforespørsel. Post til en påloggingsform importert fra Django, autentisere brukerkontoen og logg inn brukeren før vi omdirigerer dem til feed -appen vår.

I brukere/visninger.py, legg til følgende kode

        username = request.POST['username'] # Få brukernavn og passord fra innleggsforespørselen
        password = request.POST['password'] # Autentiser brukeren

Dette er alt du trenger for en grunnleggende påloggingsvisning. La oss nå lage et skjema for visningen ved å utvide basemalen. Vi starter med å opprette en ny katalog for maler i brukermappen.

mkdir users/templates
mkdir users/templates/users

Nå skal vi kunne redigere brukere/maler/brukere/login.html. Mens vi er inne på det, oppretter vi en mal for å la brukeren også registrere seg.

nano users/templates/users/login.html

Nå, i malen,

Dette er det grunnleggende i en påloggingsmal. Det er egentlig akkurat som den andre malen i struktur, men den ser litt annerledes ut når den er gjengitt. Vi kan kopiere denne koden for å bygge en annen veldig lignende mal kalt register.html, hvor vi vil endre ordlyden og bruke et nytt skjema vi bygger. La oss lage malen først. Rediger brukere/maler/brukere/register.html og legg til følgende kode:

La oss nå bygge et skjema for vår brukerregistrering og sirkel tilbake til visningene før vi oppgraderer brukerloggene våre med en modell. Vi vil gjøre dette skjemaet grunnleggende til å begynne med, men innlemme flere detaljer og sikkerhetsfunksjoner som avtaler og CAPTCHA i fremtiden. Rediger skjemaene med Nano -brukere/forms.py, og legg til følgende kode.

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

Så vi har en annen form her, som fungerer ganske enkelt. Det er et brukerregisterskjema med et brukernavn, e -post og passord, samt et bekrefte passordfelt. Merk at dette skjemaet ikke utvider de vanlige skjemaene. Formeklassen, det er en modellform som betyr at den har en meta. Ett felt er definert akkurat det samme, og klassemeta definerer modellen skjemaet tilsvarer resten av informasjonen som vil bli skrevet til skjemaet. Det meste av dette eksisterer allerede i Djangos innebygde brukerkreasjonsform, så vi vil bruke det som grunnlag for klassen (passert i parentesen).

Deretter vil vi undersøke visningen for å registrere en bruker, nå som vi har et skjema og en mal. Dette er en modelform, akkurat som den i den nye postvisningen. Rediger brukere/visninger.py og legg til følgende kode:

# ... import

Dette er alt vi trenger for å få en bruker registrert, men vi bør ha mer informasjon. Vi ønsker å vite tiden brukeren registrerte, hvilken tid de var sist på nettstedet, noe informasjon om dem, som en biografi, tidssone, etc. Vi må også oppdatere feedmodellen vår, post, for å gjøre rede for brukermodellen og attributtinnlegg til hver bruker. For å gjøre det, vil vi oppdatere modellene.py i begge appene. La oss starte med å redigere feedmodellen. Det skal se slik ut nå:

from django.db import models # ... import
    author = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True, related_name='posts') # Legg til denne linjen

Vær oppmerksom på den andre linjen som ble lagt til filen. Dette er en utenlandsk nøkkel, som vil tilskrive hvert innlegg til en enkelt bruker per innlegg, slik at vi kan sørge for at vi lagrer innleggene på bruker-per-brukerbasis og at det ikke kan gjøres noe innlegg uten å tilskrive det til en bruker. Vi definerer denne utenlandske nøkkelen med klassen den representerer, et slett argument for å sikre at innlegg blir slettet med brukere, null og blanke argumenter for å sikre at vi kan fjerne brukeren om nødvendig, og for å imøtekomme mangelen på en bruker på innlegg vi allerede har opprettet, og et beslektet navn, som vi kan bruke til å referere til innleggets objekter brukeren oppretter. Dette relaterte navnet, i motsetning til Post.author, forfatteren av innlegget, gir oss bruker som la ut selve innlegget. Vi kan nå få innleggene en bruker laget av Running User.posts.all (), eller forfatter.posts.all ().

La oss nå gjøre påloggingene våre mer spenstige. Vi kan allerede gjøre nettstedet vårt mye mindre sårbart for phishing ved ganske enkelt å begrense antall ganger vi vil tillate en pålogging på nettstedet, dette er ganske enkelt. La oss også begynne å lagre litt informasjon om hver bruker før når vi fortsetter å utvikle appen vår. Redigering av brukere/modeller.Py, legg til følgende kode.

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

Merk at denne modellen er ganske lik innleggsmodellen. Vi har en ekstra import, tidssone, som lar oss angi standardverdier på datetime -feltene, og vi har også et karakterfisk og tekstfelt som innlegget. Ved å bruke alle disse tidsstempelene hjelper oss med å sikre nettstedet og forstå bruken av det, og tekstfeltene lar oss gi informasjon om hver bruker eller forfatter på nettstedet. OneToonefield skal være den eneste mindre hensynet, den oppfører seg nøyaktig den samme som en foreginke, men med bare en per påfølgende modell. På denne måten har brukeren bare en profil, mens de kan ha mange innlegg.

La oss nå forbedre innloggingen og registrere visninger for å redegjøre for profilen. Først rediger brukere/visninger. PY og fokuser på registervisningen:

# ... import
            Profile.objects.create(user=user) # Sørg for å legge til denne linjen, for å opprette en profil for brukeren

Dette oppretter ganske enkelt en profil for brukeren, uten å fylle ut noe av informasjonen. Nå vil vi sørge for at brukerkontoen ikke kan logges inn for ofte, eller at i det minste ikke kan prøves passord for ofte, så la oss oppdatere påloggingsvisningen.

# ... import
        if user and user.profile.can_login < timezone.now(): # Merk at vi nå sjekker om brukeren kan logge inn
        else: # Hvis påloggingen ikke var vellykket,
            user = User.objects.filter(username=username).first() # Dette er den delen der vi oppdaterer brukerprofilen
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # Så de kan ikke logge inn igjen i noen sekunder

Dette er det grunnleggende grunnleggende av sikkerhet. Forsikre deg om at nettstedet ikke er sårbart for noen som bare prøver alle mulige passordkombinasjon, eller til og med noen få av dem samtidig. Dette vil ikke være frustrerende for den vanlige brukeren som kjenner passordet og bare logger seg på noen få enheter, men det vil holde mange phishing -roboter utenfor appen. Merk at vi la til en IF -uttalelse med en variabel, can_login, det skal være en tid i fortiden, og oppdatere den med hver mislykket pålogging ved å bruke det samme brukernavnet. På denne måten vil en ondsinnet bruker ikke kunne gjette et passord hvor som helst like raskt. Antall sekunder i datetime.timedelta () kan også oppdateres, og nettstedet vil være mer spenstig, men likevel litt mindre brukbart med flere sekunder. Jeg anbefaler 15 til å begynne med.

Husk at vi bygde et sikkerhetskopieringsskript for å redde arbeidet vårt, så la oss gå foran det vi har så langt for å sikre at vi har alt lagret. Kjør kommandoen:

sudo backup

Nok en gang vil dette spare arbeidet ditt så langt. Jeg anbefaler å kjøre hyppige sikkerhetskopier for å lagre arbeidet ditt, og du vil kanskje til og med kjøre en backupjobb automatisk. Du kan gjøre dette ved hjelp av et UNIX -verktøy som heter Cron. For å aktivere dette verktøyet, kjør følgende kommando og skriv inn passordet ditt:

sudo crontab -e

Hvis du ikke allerede har valgt alternativ 1 for Nano, bør tekstredigereren du allerede skal være kjent med, og bla til bunnen av filen ved hjelp av piltastene. Legg til følgende linje:

0 * * * * sudo backup

Cron bruker formatet Minute, Hour, Day of Month, Month, Day of Week, hvor et * eller et tall representerer når du skal kjøre kommandoen. Ved å bruke en 0 for minuttet og * for resten av alternativene, kan vi kjøre en kommando det første minuttet av hver time i starten av minuttet. Dette lar oss sikkerhetskopiere koden automatisk. Alle CRONs jobber når de utføres med sudo -løp som rot, så vi trenger ikke å skrive inn et passord hver time.

For å gjøre det lettere å sikkerhetskopiere koden vår uten å bruke et passord, la oss deaktivere passordet for sikkerhetskopieringskommandoen vår. Vi vil gjøre dette ved å utføre følgende kommando og legge inn et passord:

sudo visudo

La oss nå bla til bunnen av filen og legge til en annen linje:

ALL ALL=NOPASSWD: /bin/backup

Dette lar oss kjøre kommandoen "sikkerhetskopi" som enhver bruker, uten passord. Formatet for dette er enkelt, bare prefix linjen med "alle alle = nopasswd:/bin/" og avslutt med kommandoen, for eksempel/bin/backup, som finnes i/usr/bin/.

La oss nå begynne å jobbe med e -post. E -post er veldig viktig for nettsteder, fordi det er en måte å holde et nettsted sikrere, bekrefte at brukere er virkelige mennesker, og til og med markedsprodukter eller tjenester til kundene. Mange mennesker som ofte sjekker e -posten deres daglig, og mottar alle slags markedsføringsmail om produkter og tjenester de er interessert i. Det er noen få alternativer når det gjelder å aktivere e -post på et Django -nettsted, og du er velkommen til å velge det som fungerer best for deg.

Først kan du betale for en e -posttjeneste som lar deg sende e -post fra domenet ditt og krever minimal kode. Det er mange tjenester som tilbyr dette, for eksempel Google Workspace, SendinBlue, Mailgun og mer.

Ellers har du det bra med å bygge din egen e -posttjeneste på serveren din fra bunnen av. Jeg anbefaler dette alternativet, selv om det er mer kode og kan kreve spesiell hosting. Du vil ikke kunne starte en e -postserver fra hjemme -datamaskinen din mest sannsynlig, så la oss gå foran og undersøke konfigurasjonen og koden for å sende e -post før vi starter en server i skyen og oppretter vår egen e -postserver innen.

Først rediger innstillinger.py med følgende kommando:

nano app/settings.py

Hvor appen er navnet på appen du opprettet med StartApp.

Legg til følgende linjer:

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)

Sørg for å endre disse når du er klar til å distribuere appen din, vi vil se på dette senere. Innstillingen e -post_adress skal være e -posten du vil sende fra, og passordet (e -post_host_password) skal settes til passordet du genererer for serveren. Jeg laster inn passordet fra en konfigurasjonsfil for å holde den utenfor koden ved å bruke følgende logikk, over disse linjene i innstillinger.

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

Deretter har jeg satt opp en JSON -fil med konfigurasjonen i /etc/config.json ved å bruke Nano som følger.

For å redigere filen:

sudo nano /etc/config.json

Legg til følgende linjer:

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

Vi vil fortsette å redigere konfigurasjonsfilen og legge til alle passord og nøkler vi bruker i appen. Foreløpig, la oss raskt undersøke hvordan du sender e -post ved hjelp av Python. La oss først opprette en mal for en verifisering -e -post vi kan sende til brukerne våre, og legge den inn i brukermalkatalogen. Denne malen vil bli skrevet i HTML.

nano users/templates/users/verification_email.html

Denne e -posten er ganske enkel. Det tar en kontekst av en bruker, basis -URL for nettstedet, og en bruker -ID og token som brukes til å bekrefte brukerens e -post. Sørg for å definere basis -URL -en i innstillinger. Gå videre og legg til følgende linjer i app/innstillinger.py, nær begynnelsen.

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

BASE_URL = PROTOCOL + '://' + DOMAIN

Etter hvert, når nettstedet ditt er klart for internett og du distribuerer det, vil du definere domenet ditt som domenenavnet du kjøper for å representere nettstedet. Dette er navnet du vil skrive inn navbaren for å få tilgang til nettstedet ditt. Foreløpig kan du la domenet være tomt eller bruke en plassholder. Du vil også ønske å endre nettstedets navn til et navn du vil gi nettstedet ditt, du velger.

Før vi sender e -post, la oss opprette en token -generator slik at vi kan ha en kontoaktiveringstoken som aldri utløper. Vi kan gjøre dette ved å bygge og importere en kontoaktiveringstoken som ser ut som følgende. Rediger filen:

nano users/tokens.py

Legg til følgende kode:

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

Denne grunnleggende tokengeneratoren genererer et token vi kan sende brukeren i en URL, og brukeren kan bruke for å bekrefte e -posten deres og aktivere kontoen sin.

La oss deretter se hvordan du sender en e -post. Bruke Nano, rediger brukere/e -post.py.

nano users/email.py

Å sende verifiseringen HTML -e -post vil se slik ut:

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)

Dette er ganske enkelt. Vi importerer funksjonene vi trenger for å sende e -posten, gjengi e -posten med maler og innstillingene våre, og deretter definerer vi e -posten med malnavnet og sender den til brukeren ved hjelp av en funksjon. Du vil merke at vi ikke har definert funksjonen for å sende posten, send_html_email, men la oss skrive dette under koden vi allerede har lagt til brukere/e -post.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()

Dette er litt mer sammensatt, og vi er ikke klare til å kjøre all denne koden ennå. Legg merke til at vi definerer en unsub_link, lenken brukeren kan bruke til å melde seg ut fra e -postene våre. Dette er viktig, fordi brukere må være i stand til å velge bort e -postene våre med mindre de når som helst vil se dem. Vi legger også til et tekstalternativ til meldingen vår, som er HTML -meldingen som er strippet for HTML -tagger. Til slutt sjekker vi om e -posten som ble sendt, og hvis den ikke gjorde det, markerer vi i brukerens profil at e -posten deres ikke er gyldig.

La oss flytte tilbake til brukermodellene slik at vi kan få dette til å fungere. Vi må definere en funksjon for å generere en lenke til å avslutte abonnementet, og definere et boolsk felt for å merke at brukerens e -post ikke er gyldig.

Først må du legge til følgende import til toppen av brukere/modeller.

nano users/models.py

# ...

La oss deretter legge til funksjoner til brukermodellen for å lage tokenet og sjekke tokenet som brukes til å aktivere e -posten, så vel som feltet for å spare om brukeren lykkes med å motta posten. I brukere/modeller.

# ...
            TimestampSigner().unsign(key, max_age=60 * 60 * 24 * 30) # Gyldig i 30 dager

Dette er ganske enkelt, vi bruker en tidsstempler, som er et grunnleggende kryptografiverktøy, for å lage et symbol som vil utløpe etter en viss tid, og vi bruker også en annen funksjon for å sjekke om det er gyldig. Vi bruker disse symbolene to ganger, en gang for å bekrefte e -posten, og en gang for en avmeldingslenke.

Nå som vi har disse, er det siste av arbeidet vi trenger å gjøre i synspunktene. Innenfor brukere/visninger.Py, la oss legge til visninger for å bekrefte e -postadressen, og for å melde deg av.

nano users/views.py

Først må du legge til følgende import. Jeg kastet inn noen ekstra ekstra, så vi slipper å importere flere varer igjen senere.

from .email import send_verification_email # Sørg for å importere verifiserings -e -postsendingsfunksjonen

Du har kanskje allerede noen av disse importen, men det skader ikke å gjenta dem. Du trenger å importere verifiserings -e -postsendingsfunksjonen, samt konto_aktivering_token fra brukere.tokens, blant annet import.

Nå, nederst i filen, legger du til følgende kode:

        # Avslutt dem
    # Ellers omdirigerer til påloggingsside
# SendWelcomeMail (forespørsel, bruker)

Dette er mye kode. La oss bryte det ned. Den første funksjonen, rene og enkel, avslutter brukeren fra adresselisten. Den andre funksjonen aktiverer e -posten deres, og du vil merke at jeg la til en kommentert funksjon, SendWelcomeEmail. Du er velkommen til å bruke en definisjon av e -postmal og funksjon for å sende en velkomst -e -post, det har jeg ennå ikke ennå. Den siste funksjonen jeg kastet inn er viktig, fordi aktivering av e -post går ut. Derfor må vi sende aktivering av aktivering på e -post til noe av tiden. Vi kan bruke en grunnleggende form for dette, og ringe funksjonen for å sende bekreftelses -e -posten. Før vi gjør dette, la oss sørge for at det blir sendt i utgangspunktet, ved å legge til en funksjonsanrop til registervisningen. Legg til denne linjen rett før omdirigering i registervisningen, DEF -registeret, i brukere/visninger.

nano users/views.py

# ... (etter) def register (forespørsel):
# ... (før) omdirigere (

Du trenger ikke å legge til de første og siste linjene i kodebiten, bare sørg for at registervisningen sender bekreftelses -e -posten til brukeren. Det skal se slik ut:

# ... import
            send_verification_email(user) # Sørg for å legge til denne linjen!

Nå må vi legge til et skjema for å sende aktiverings -e -posten på nytt. I brukere/skjemaer.Py, legg til følgende skjema:

# ... (import)

Vi vil også trenge en mal som tilsvarer dette skjemaet for aktivering av e -post. La oss legge til denne malen i. Rediger filen:

nano users/templates/users/resend_activation.html

Deretter legger du til følgende kode i filen.

Whew, det er mye! Når vi distribuerer koden til serveren vår, vil vi kunne sende HTML -e -post og aktivere brukerkontoer med et klikk i e -posten. Vi vil kanskje også sende en enkel velkomst -e -post, så la oss se hvordan vi gjør det. Tilbake i brukere/e -post.py, legg til følgende kode:

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)

Vi trenger også en mal for å gjengi all denne informasjonen. På nettstedet mitt ser malen ut som nedenfor, men du er velkommen til å formatere den slik du vil.

Merk at vi ikke har lukkende kropps- eller HTML -tagger, fordi vi legger disse til når vi legger til HTML -avmeldingslenken. Disse er viktige, men vi vil ikke definere dem to ganger.

Så hva er det neste? Vi har kommet langt. Virkelig, vi bør være klare til å distribuere nettstedet til en server. Vi kan legge til @login_required Decorator og gjøre visningene våre sikre, ta brukeroppmeldinger, sende kompatibel e -post og cacheinformasjon, som er grunnlaget for hva et nettsted må gjøre for å holde deg relevant. Vi vil legge til noen flere nyttige funksjoner, og deretter bygge et grunnlag for å distribuere koden vår til en ekstern server, sette opp en postserver, domenekonfigurasjon og filtre for å gjøre nettstedet vårt sikkert og passende.

Vi trenger også en tilbakestilling av passord, så la oss legge til det veldig raskt. Djangos innebygde tilbakestillingsvisning av passord er ødelagt i noen funksjoner, men vi ser på hvordan vi skal skrive vår egen visning, e -postmal, skjemaer og URL -mønstre. Her er hvordan visningen ser ut, i brukere/visninger.py

# ... import

Dette skjemaet er innebygd i Django, men vi trenger en mal for å bekrefte tilbakestillingen av passordet, brukere/maler/brukere/passord_reset_confirm.html

Vi har også en mal for å sende en tilbakestilling av passord, med et enkelt skjema, hos brukere/maler/brukere/passord_reset.html

Malen for selve e -posten er enkel, det er en grunnleggende HTML -fil som gjengir en lenke for å tilbakestille passordet, hos brukere/maler/brukere/passord_reset_email.html. Django vil automatisk tolke denne filen.

Vi trenger også to maler til. Den første er å bekrefte at e -posten er sendt. Visninger for disse er allerede i Django, så vi trenger bare å adressere dem i nettadressene.py. Denne malen er lokalisert hos brukere/maler/brukere/passord_reset_done.html

Og til slutt, for å bekrefte at tilbakestillingen av passordet er fullført, bruker bruker/maler/brukere/passord_reset_complete.html

Nå trenger vi URL -mønstre for disse visningene. I brukere/urls.py, legg til følgende URL -mønstre:

    # ... Tidligere nettadresser her

Fire maler, det er mye! Men nå kan vi være sikre på å kunne tilbakestille brukerens passord når som helst vi trenger, alt fra nettleseren.

Jeg forstår at dette er mye kode. Hvis det virker litt over hodet, er det OK. Du vil forbedre deg, forståelsen din vil bli bedre, og du vil bli mye mer kompetent med kode ganske snart. Hvis du er helt tapt, anbefaler jeg at jeg kommer tilbake til denne programvaren senere etter å ha jobbet med et selvtydelig å lære å kode kurs på nettet. Disse er vanligvis gratis å komme i gang, og vil guide deg gjennom alt du trenger for å lykkes når du kommer tilbake til dette prosjektet. Hvis du føler at du er klar til å fortsette, lese videre, neste, vil vi dekke distribusjonen av koden til en ekstern server og sette opp en e -postserver, samt automatisere distribusjonen din ved å bruke Bash, slik at du alltid kan sette opp et nytt prosjekt med noen enkle kommandoer.

Det siste vi trenger å gjøre før vi distribuerer til en ekstern server er å gjøre nettstedet vårt litt sikrere. Du vil merke at påloggingsvisningen bare tar et brukernavn og passord, og det er ingen multifaktorautentisering eller en tidskode. Dette er en enkel løsning, og med samme kode kan vi få nettstedet vårt til å sende tekstmeldinger og til og med være lydhør over tekstmeldinger sendt til serveren. For å starte, vil vi gå tilbake i brukermodellene og legge til en tidsstempel som vil representere hver pålogging. Vi vil også legge til en unik, roterende identifikator til brukermodellen som vil bli brukt til å legge til ekstra sikkerhet til innloggingen vår. Redigering av brukermodellene, brukere/modeller.PY, legg til følgende kode:

# Sørg for å importere UUID, Timestamp Signer og URL Generator (omvendt)
    # Legg til denne koden her
    # Og legg til denne funksjonen
            TimestampSigner().unsign(key, max_age=60 * settings.AUTH_VALID_MINUTES) # Gyldig i 3 minutter

Forsikre deg om at brukerne/modellene dine ser slik ut, i tillegg til kommentarene (kode på linjene med #). Å bryte dette ned, det er enkelt. Vi har noen få importer, en tidsstempelssigner som er et kryptografisk verktøy som kan generere en sikker kode og bekrefte den for å sikre at den er gyldig, bare blitt brukt en gang, og ikke eldre enn et visst antall sekunder. Vi bruker også en UUID, som er en unik identifikator som identifiserer vår bruker i signeringen av tokenet, og i URL -en der tokenet sendes til brukeren. Vi bruker denne grunnleggende kryptografien til å bygge en tofaktor autentiseringsvisning. Før vi gjør noe annet, la oss kjøre migrasjonene slik at brukermodellene våre blir oppdatert. I katalogen med administrasjon.py, kjør følgende kommandoer for å gjøre og fullføre migrasjonene.

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

Dette er viktig fordi hver gang vi gjør endringer i modellene, må vi opprette tabellene og oppdatere databasen med standardverdier før vi faktisk kan bruke modellene.

La oss deretter improvisere innloggingsvisningen vår for å omdirigere til et sekundært autentiseringsvisning. Hos brukere/visninger.

# ... import
        if user and user.profile.can_login < timezone.now(): # Merk at vi nå sjekker om brukeren kan logge inn
            # Fjern auth_loginfunksjonen som var her
                return redirect(user.profile.create_auth_url()) # Merk at vi omdirigerer til en ny url her
            else: # Hvis brukeren ikke bruker multifaktorautentisering, er det bare å logge dem inn.
        else: # Hvis påloggingen ikke var vellykket,
            user = User.objects.filter(username=username).first() # Dette er den delen der vi oppdaterer brukerprofilen
                profile.can_login = timezone.now() + datetime.timedelta(seconds=15) # Så de kan ikke logge inn igjen i noen sekunder

Så dette er ganske enkelt, vi har nå en måte å omdirigere til de to faktorautentiseringsvisningen når vi oppretter det. Vi har også en tilbakeslag i tilfelle brukeren ikke har lagt til et telefonnummer. Vi vil legge til en grunnleggende visning for å legge til et telefonnummer snart og logge inn med en tekstmelding snart.

Først trenger vi en enkel måte å sende en tekstmelding fra koden vår. For å gjøre dette kan vi velge mellom en rekke API -er, men den enkleste etter min mening er Twilio. De tilbyr også gode priser for mindre prosjekter, samt bulkrabatter. Opprett en konto på Twilio.com, fyll ut noen detaljer om prosjektet ditt, kjøp et telefonnummer og kopier API -nøklene til innstillingene dine. Deretter legger du til denne koden under en ny fil, brukere/sms.py.

nano users/sms.py

# Importer alle nødvendige pakker
# Denne koden sender teksten med Twilio
# En hjelperfunksjon for å få et tall med så mange sifre
# Send teksten for å bekrefte brukeren
# Send en bruker hvilken som helst tekst med denne funksjonen
# Valider koden med denne funksjonen
# Valider tiden

Sørg for å endre innstillingene på riktig måte, legg til disse linjene med nøklene dine:

# Sørg for å kopiere disse fra Twilio -dashbordet ditt
AUTH_VALID_MINUTES = 3 # Antall minutter TFA -siden er aktiv når du er instantiert

Først vil vi trenge skjemaer for våre to faktorautentiseringsvisninger. Redigerer brukere/skjemaer. Py, legg til følgende kode.

# ... import
# Et skjema for å legge inn telefonnummeret vårt
# Et skjema for autentisering

Neste, la oss lage visningene i brukere/visninger.py

# ... import

Vi trenger også maler for begge disse visningene. La oss legge til MFA -malen først.

nano users/templates/users/mfa.html

Legg til denne HTML -koden i malen

Dette er ganske selvforklarende. Skjemaet sender enten en kode eller en tom kode, og du vil legge merke til i visningen vi sender koden hvis vi mottar en tom kode. Da har vi bare to innsendingsknapper, og på denne måten kan vi sende koden med begge knappene. Deretter legger vi til et enkelt skjema for å legge til et telefonnummer.

nano users/templates/users/mfa_onboarding.html

Legg til følgende HTML:

Dette skjemaet er mye enklere, det gjengir bare telefonnummerskjemaet vi opprettet og lar brukeren legge til et telefonnummer.

Dette ser veldig bra ut! Så lenge alt er riktig satt opp, skal vi kunne sende meldinger og logge brukeren inn med telefonnummeret sitt så snart vi legger til URL -mønstrene. Det siste vi trenger å konfigurere er en profilvisning, slik at vi kan sørge for at brukeren kan endre telefonnummeret uten å bli logget inn. Også, til slutt vil vi legge til et "Stopp for å slutte" -alternativet, slik at brukeren kan sende en tekstmelding til "Stop" for å velge bort fremtidige tekstmeldinger.

La oss legge til en profilvisning til brukerne/visningene. Denne visningen vil oppdatere brukerens biograf, e -post, brukernavn og telefonnummer, samt tillate oss å aktivere autentisering av flere faktor. Først trenger vi to skjemaer til i brukere/skjemaer.

# ... import

Deretter kan vi lage et syn på å bruke begge disse skjemaene. Rediger brukere/visninger.py og legg til visningen.

# Legg til denne importen

Vi trenger også en mal for denne visningen.

nano users/templates/users/profile.html

Du vil merke at dette er en ganske enkel form, men har noe JavaScript i seg som automatisk legger inn innholdet i skjemaet når de er oppdatert. Dette er nyttig å ha, slik at du kan gjøre redigeringer uten å måtte trykke på innsending hver gang.

Deretter trenger vi nettadresser som representerer alle disse visningene i brukerens URL -klaffer. Rediger brukere/urls.py og legg til denne koden:

# ... tidligere kode, import
# ... URL -mønstre vi tidligere har skrevet inn, legger til de tre neste linjene

Nå er det et godt tidspunkt å teste ut prosjektet vårt. Men først, la oss kjøre en ny sikkerhetskopi.

backup

Og kjør serveren. Før vi distribuerer til en Linux -server, er det en god idé å aktivere to faktorautentisering på kontoen. Vi vil gjøre dette til å gå til profil -URL -en,/brukere/profil/, og merke av i boksen for å aktivere autentisering etter å ha lagt inn telefonnummeret vårt, og deretter sende inn skjemaet.

python manage.py runserver localhost:8000

Besøk nettsiden ved å gå til nettleseren din, jeg bruker Google Chrome i dette eksemplet, og skriv inn URL -URL -er: // LocalHost: 8000/Accounts/Profile/

Du vil kunne logge inn om nødvendig og aktivere to faktorautentisering.

Dette prosjektet trenger en server for å kjøre på, slik at det virkelig kan sende post. Men først trenger vi en måte å se feil på. Du vil merke at hvis du kjører serveren i feilsøkingsmodus, med innstillinger. DEBUG lik True, viser serveren feil automatisk. For å vise feil uten å bruke feilsøkingsmodus, som er utrygg på en produksjonsserver, bør vi legge til en visning for det. De viktigste feilene vi trenger å kunne håndtere er:

Feil 500 - Et problem med koden vår Feil 404 - En side som ikke ble funnet (ødelagt url) Feil 403 - En tillatelse nektet feil

La oss legge til en ny app for å håndtere disse feilene, kalt feil.

python manage.py startapp errors

Legg dette til innstillingene.

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

Dette er alt vi trenger foruten feilvisninger, maler og litt mellomvare. La oss definere dem som det:

# Lag dine synspunkter her.

La oss deretter definere mellomvaren for å håndtere disse feilene. Vi vil gjøre dette ved først å legge til mellomvare_klasser i innstillinger.py, med navnet på mellomvaren vår.

    # ... Tidligere mellomvare

Neste, la oss legge til mellomvare.

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

Vi legger til en funksjon for å få det nåværende unntaket ved å bruke en trådlokal, som hjelper oss å spore eventuelle feil i koden vår. Når det gjelder maler, trenger vi bare en, fordi vi dynamisk definerer tittelen i visningen. Malen trenger bare å gjengi tittelen og "spore", vår feilsporing fra konteksten.

nano errors/templates/errors/error.html

Dette er vår enkleste mal ennå, men det er hvor lett det er å se feilene i prosjektet vårt. La oss deretter deaktivere feilsøking i innstillinger.

nano app/settings.py

Finn denne linjen der den er satt til sann, og endre den til falsk

DEBUG = False

Gå videre og ta sikkerhetskopi av appen nå. Vi er klare til å distribuere til en ekstern Linux -server, og fortsetter å legge til funksjoner derfra.

sudo backup

Før vi legger ut denne koden på en server, bør vi vurdere at det kan være noen problemer med koden. Avhengig av saken, vil nettsteder som godtar informasjon som er lagt ut til dem, ha problemer med at spam blir lagt ut og vanskeligheter med å fjerne spam. Dette skal ikke skje umiddelbart, men hvis det skjer, vil vi senere undersøke hvordan du automatisk skal moderere spam på nettstedet og gjøre det tøffere for roboter å få tilgang til nettstedet, sammen med hvordan du kan deaktivere brukerkontoer, og bekrefte en brukers identitet med en skanning av deres ID eller en biometrisk skanning, som et fingeravtrykk eller ansiktsgjenkjenning.

Når du ser på multifaktor -autentiseringseksemplet vi undersøkte, i produksjon, kan ting være annerledes. Legg merke til hvordan vi er prisbegrensende pålogginger og utløpende symboler. Hvis roboter får tilgang til et nettsted, kan to faktorautentisering være vanskeligere, da de kan legge inn koder samtidig som brukeren er. For å bekjempe dette, la oss bruke en modell i brukermodellene, og erklære hvordan vi samhandler med nettstedet når vi autentiserer ved hjelp av multi -faktorautentisering med et telefonnummer. Vi vil også legge til et alternativ for å autentisere med e -post. Begynn med å redigere brukermodellene med Nano.

nano users/models.py

Dette er slik modellen vi legger til, skal se ut. Vi trenger ingen metoder, bare variabler for å lagre en ID, brukeren, tidsstempel, utløp, lengde og forsøk mot en hvilken som helst autentisering av flere faktor (en kode som 123456 sendt til en telefon eller e -post).

# Et grunnleggende token pleide å logge inn på nettstedet

La oss også legge til et privilegium til vår bruker, og vi vil stille det manuelt for nå, før vi til slutt migrerer til å verve privilegerte brukere automatisk. I brukermodellene, legg til denne linjen i profilen:

    vendor = models.BooleanField(default=False)

Som med alle endringer i databasen, må vi gjøre migrasjoner og migrere databasen når vi redigerer en modeller.py -fil i Django. Husk at for å gjøre dette bruker vi kilden først (hvis den ikke har blitt brukt allerede siden terminalen var åpen) og deretter python administrere.py for å gjøre migrasjonene og migrere.

cd project-directory-you-named # (om nødvendig)

Foreløpig kan du verve alle kontoer du har opprettet som leverandører ved å bruke skallet.

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

La oss nå utvikle vår autentiseringsvisning for flere faktor for å bruke dette tokenet. Først må vi endre MFA -hjelperverktøyene våre. Bruker 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

# Autentiser brukeren ved å bruke e -post eller telefonnummer
    token = MFAToken.objects.filter(uid=username, expires__gt=timezone.now() + datetime.timedelta(seconds=30)).order_by('-timestamp').last() # Filtrer tokenet med verdien som er gitt i nettadressen (en 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)) # Hvis denne økten ikke er opprettet, oppretter du den
    user = User.objects.filter(id=token.user.id).first() # Få brukeren fra tokenet
    if not user and request.user.is_authenticated: return redirect(reverse('feed:home')) # Hvis de allerede er autentisert, logg dem inn
    if not user: raise PermissionDenied() # Nekte hvis ingen bruker ble funnet
    if not user.profile.enable_two_factor_authentication and user.is_active and user.profile.check_auth_token(usertoken, token): # Sjekk authentetokenet
        auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Logg inn brukeren hvis de ikke allerede er logget inn
        user.profile.mfa_expires = timezone.now() + datetime.timedelta(minutes=settings.LOGIN_VALID_MINUTES) # Angi en utløp på autentisering av flere faktor
        return HttpResponseRedirect(next if next != '' else reverse('landing:landing')) # Omdirigere brukeren til neste side
    if not user.profile.mfa_enabled: # Sjekk om MFA er aktivert
        if not check_verification_time(user, token): # Sjekk tiden
            user.profile.mfa_enabled = False # Fjern telefonnummeret
            user.profile.enable_two_factor_authentication = True # Aktiver MFA
            user.profile.phone_number = '+1' # Deaktiver telefonnummeret
            user.profile.save() # Lagre profilen
            auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Logg brukeren inn hvis deres MFA ikke er aktivert
    if request.method == 'POST' and not fraud_detect(request, True): # Hvis forespørselen er en etterforespørsel
        form = TfaForm(request.POST) # Øyeblikkelig skjemaet
        code = str(form.data.get('code', None)) # Få koden
        if code and code != '' and code != None: # Forsikre deg om at det ikke er tomt
            token_validated = user.profile.check_auth_token(usertoken) # Sjekk authentetokenet
            is_verified = check_verification_code(user, token, code) # Sjekk koden
            if token_validated: # Hvis alt
                if is_verified: # Er i orden
                    user.profile.mfa_enabled = True # Aktiver MFA (hvis ikke allerede aktivert)
                    auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') # Logg inn brukeren
                    for key, value in request.GET.items(): # Bygg en spørring for neste parameter (hvis noen)
                        return HttpResponseRedirect(next) # Omdirigere
            elif not token_validated: # Hvis tokenet var ugyldig
            if p.mfa_attempts > 3: # Hvis det var for mange forsøk
            if form.data.get('send_email', False): # Send e -posten (eller tekst)
    # Gjengi skjemaet (for få forespørsler)

Når vi legger til denne koden, må du sørge for å importere funksjonen for å sende en e -post. Øverst i filen vises brukeren (med annen import), legg til

from .mfa import send_verification_email as send_mfa_verification_email

Nå må vi skrive den funksjonen før noe av dette vil fungere. Den skal utvide vår Send -e -postfunksjon, og bare sende en e -post til brukeren med bekreftelseskoden.

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

Så alt dette fungerer bra, nå har vi et autentiseringssystem for flere faktor som avhenger av et telefonnummer eller e -post for å logge inn. Men vi trenger også en måte å fjerne, eller i det minste skjule brukere som ikke samarbeider med vilkårene våre. Dette kan være spammere, roboter eller alle som ikke betyr godt for vårt arbeid. Ta en titt på en visning jeg har for å overvåke brukere på nettstedet mitt:

# Import
from .tests import is_superuser_or_vendor # Vi må lage denne testen
    # Få liste over brukere
    return render(request, 'users/users.html', { # Returner brukere i en mal

Merk at denne koden bruker en test, vi må erklære denne testen i en tester.py -fil og importere den. Redigering av brukere/tester. Py, la oss opprette testen.

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

Dette er i forbindelse med brukerne/brukerne.html -malen, som ser ut som dette:

Merk at malen inkluderer en annen mal, brukere/bruker.html. Når du bruker en mal som har en subtemplate og ikke bruker utvides, er det en god idé å legge til en understrek () før navnet på filen som skal utvides, for å skille maler.

Merk at dette er mye jinja, det er ikke sikkert at du har alle disse variablene definert. Men slik ser koden min ut.

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

Vi trenger også en annen subtemplate, Toggle_active.html. Denne malen skal være et skjema som lar oss veksle om en bruker er aktiv.

Vi må også legge til en visning til å veksle brukeraktivitet og passende URL -mønstre. Mens vi er inne på det, la oss legge til en visning for å slette en bruker i tilfelle vi trenger det.

# Import
    success_url = '/' # Omdirigering av suksess -url
    def test_func(self): # Test om brukeren er superbruker og har tillatelse til å slette

Selv om dette er praktisk når det er nødvendig, bør du slette en bruker ikke være nødvendig mesteparten av tiden, kan vi bare bytte synligheten til brukere som besøker nettstedet hvis vi trenger å avvise dem.

URL -mønstrene vi la til ser slik ut. Med Nano, rediger brukere/urls.py og legg til disse linjene:

nano users/urls.py

Linjene skal gå i listen over stier i brukervisninger, før avslutningen "]" men etter begynnelsen "[".

# ...
# ...

Sørg for å sikkerhetskopiere nettstedet slik at du kan laste ned det på webserveren vi fortsetter å jobbe med. Fra kommandolinjen,

sudo backup

Nå er nettstedet vårt sikkerhetskopiert.

Så nå har vi noen flere nyttige funksjoner. Men hva med det store bildet her? Denne koden er fremdeles ikke tilgjengelig fra Internett, vi har ingen e -postserver ennå, og vi må utvide appen vår til å omfatte omfattende verifiseringsprosess samt glatte oppsett for å hjelpe oss med å utforske nettstedet, sammen med sikre protokoller for autentisering av privilegerte brukere.

Vi kommer til alt dette. Det viktigste for nå vil bare være å få denne koden på nettet, noe vi kan gjøre med bare noen få linjer med bash på en Ubuntu -server. Du må leie en server for dette, med mindre du har en server hjemme og et virksomhetsinternettabonnement som lar deg åpne porter. Jeg personlig kjører nettstedet mitt på en HP Z440 som er installert i leiligheten min, men det er vanligvis mye billigere for grunnleggende behov for å leie en virtuell privat server (VPS).

Husk at koden vi kjører nå er relativt tynn, den må opprettholdes og forbedres før vi er klare til å bruke det vi har for å bygge et produkt. Sørg for å være forsiktig med hva du gjør med Internett, sørg for at hvis du distribuerer dette nettstedet offentlig til nettet på en Linux -server, har du en plan for å blokkere uønskede interaksjoner med nettstedet ditt. Dette vil sannsynligvis ikke være et problem med det første, men vi vil se på en rekke løsninger for å bekjempe dette, inkludert maskinlæring, kunstig intelligens og datasyn. Når det blir et problem, kan du se nærmere i denne teksten for en løsning.

Når det gjelder å leie en VPS, er det mange steder du kan gå. Google Cloud har VPS -servere, Ionos, Kamatera, Amazon AWS, og flere leverandører tilbyr skyserverløsninger som passer våre behov.

Du må klikke gjennom skjemaene deres og velge en plan for å komme i gang. Du kan gå med en grunnleggende plan med hvilken som helst leverandør, men sørg for at leverandøren lar deg åpne Port Mail Server -porter for å sende e -post (dette skal være port 587 og port 25), noen leverandører blokkerer disse portene. Så langt har jeg hatt den beste opplevelsen med Ionos og Kamatera, begge av dem vil tillate meg å sende ubegrenset e -post og prisene deres er ganske billig.

Du vil koble deg til den nye serveren din over en protokoll som heter SSH eller Secure Shell, som lar deg eksternt grensesnitt med serveren akkurat som din personlige datamaskin, fra din personlige datamaskin. Når du setter opp serveren, vil vertsleverandøren sannsynligvis be deg om å legge til en SSH -nøkkel, ellers vil de gi deg et brukernavn og passord. SSH -tasten er hvordan du vil logge deg på serveren fra kommandolinjen for å redigere koden. Bruk alternativene nedenfor SSH-Keegen for å generere en SSH-tast.

ssh-keygen

Lagre filen og overskriv den hvis du trenger det, det er godt å rotere SSH -tastene hvis du ikke allerede har gjort det. Nå kan du bruke følgende kommando for å se SSH -tasten din. Du vil kopiere den til den eksterne serveren din, slik at du kan bruke den til å autentisere.

cat ~/.ssh/id_rsa.pub

Hvis du ikke kunne se en SSH-tast når du skriver den kommandoen (en lang streng med sifre og bokstaver som starter med "SSH-RSA AAA"), kan du prøve å generere en RSA-nøkkel (de er sikrere, så jeg anbefaler å bruke dem.) Følgende kode vil generere en 4096 bit RSA SSH-nøkkel.

ssh-keygen -t rsa -b 4096

Lag en VPS som kjører Ubuntu, men du planlegger å gjøre dette. Når du har opprettet en VPS ved å klikke gjennom skjemaene på leverandørens nettsted (kamatera.com, ionos.com eller lignende), vil du logge deg på. For å gjøre dette, bruk SSH -kommandoen med din IP -adresse (adressen som ser ut som xx.xx.xx.xx). Du må også være følsom for standard brukernavn på serveren vi opprettet, for eksempel Ubuntu.

ssh ubuntu@XX.XX.XX.XX

Du kan bli bedt om et passord.

La oss starte med å legge til en ny SSHD_CONFIG -fil, som forteller serveren hvordan du bruker SSH.

nano sshd_config

# Dette er SSHD-serverens systemomfattende konfigurasjonsfil.  Se
# sshd_config (5) for mer informasjon.
# Denne SSHD ble satt sammen med Path =/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
# Strategien som brukes til alternativer i standard SSHD_CONFIG sendt med
# OpenSSH skal spesifisere alternativer med standardverdien der
# mulig, men la dem kommentert.  Uformidlet alternativer overstyrer
# standardverdi.
# Port 22
# Adressefamilie noen
# Listenadress 0.0.0.0
# ListenAddress ::
# HostKey/etc/ssh/ssh_host_rsa_key
# HostKey/etc/ssh/ssh_host_ecdsa_key
# HostKey/etc/ssh/ssh_host_ed25519_key
# Chiffer og tasting
# REKEYLIMIT standard Ingen
# Logging
# SyslogFacility Auth
# LOGLEVEL INFO
# Autentisering:
# LogingRacetime 2M
# Tillatootlogin Forbudsmessig pass
# StrictModes Ja
# Maxauthtries 6
# MaxSessions 10
# Forvent .SSH/Authorised_Keys2 som blir sett bort fra som standard i fremtiden.
# Autorisert PrincipalsFile Ingen
# AutorisertKeyScommand ingen
# AutorizedKeyScommanduser ingen
# For at dette skal fungere, trenger du også vertsnøkler i/etc/ssh/ssh_neknede_hosts
# HostbasedAuthentication nr
# Endre til ja hvis du ikke stoler på ~/.ssh/kjente_hosts for
# HostbasedAuthentication
# IgnoreUsernknytterne nr
# Ikke les brukerens ~/.rhosts og ~/.hosts -filer
# Ignorerehosts ja
# For å deaktivere tunnelerte klare tekstpassord, endre til nei her!
# TillatelsePassord nr
# Endre til Ja for å aktivere passord for utfordringer-svar (pass på problemer med
# noen PAM -moduler og tråder)
# Kerberos -alternativer
# Kerberosauthentication nr
# KerberosorlocalPasswd Ja
# Kerberosticketcleanup Ja
# Kerberosgetafstoken nei
# GSSAPI -alternativer
# Gssapiauthentication nr
# GSSAPICLEANUPCredentials Ja
# Gssapistrictacceptorcheck ja
# GSSAPIKEYEXCHANGE NO
# Sett dette til 'ja' for å aktivere PAM -godkjenning, kontobehandling,
# og øktbehandling. Hvis dette er aktivert, vil PAM -godkjenning
# få lov til gjennom kbdinteractiveauthentication og
# Passordauthentication.  Avhengig av PAM -konfigurasjonen din,
# PAM -godkjenning via KBDInteractiveAuthentication kan bypass
# Innstillingen av "tillatelserootlogin utenpassord".
# Hvis du bare vil at PAM -kontoen og øktkontrollene skal kjøre uten
# PAM -godkjenning, så aktiver dette, men angi passordauthentication
# og kbdinteractiveauthentication til 'nei'.
# Tillat om fremover ja
# Tillater ja
# Gatewayports nr
# X11DisplayOffset 10
# X11uselocalhost ja
# Permittty ja
# Printlastlog ja
# Tcpkeepalive ja
# Tillatelsesmiljø nr
# Komprimering forsinket
# ClientaliveInterval 0
# Clientalivecountmax 3
# Brukt nr
# Pidfile /run/sshd.pid
# MaxStartups 10: 30: 100
# Permittunnel nr
# Chrootdirectory Ingen
# Versionaddendum Ingen
# Ingen standard bannersti
# Tillat klienten å passere variabler
# Overstyrer standard for ingen delsystemer
# Eksempel på overordnede innstillinger per brukerbasis
# Match brukeranoncvs
# X11forwarding nei
# Tillater nei
# Permittty nei
# ForceCommand CVS -server

Husk at Ctrl+X og Y for å lagre filen. La oss deretter skrive et grunnleggende skript som heter Initialize (alt i standard Home Directory til vår bruker).

nano initialize

Legg disse linjene i filen, og erstattetMed din SSH -tast fant du ved hjelp av CAT. (.SSH/ID_RSA.PUB)

# !/BIN/BASH

For å lede deg gjennom denne filen, la oss starte linje for linje. Den første linjen forteller kompilatoren at dette er et bashskript. Deretter installerer vi avhengigheter, kopierer sshd_config til riktig katalog, starter SSH på nytt, genererer SSH -nøkler for root, legger til brukeren 'team' (du kan velge et navn du liker for dette, bruk adduser -kommandoen med navnet deres og deaktiverte passordet for nå). Vi legger også til team i sudo -gruppen, genererer SSH -nøkkelen, legger til nøkkelen til autoriserte nøkler og deres også, og skriver ut nøkkelen. Denne nye brukeren vil være hvordan vi logger på nettstedet.

I en ny terminal, fortsett og åpne serveren igjen.

ssh team@XX.XX.XX.XX

Du bør ikke trenge et passord denne gangen, være som du har en SSH -nøkkel. Vi har også deaktivert pålogging med passord for å holde nettstedet sikrere.

Nå starter denne serveren helt tom uten informasjon om den. La oss starte med å klone prosjektet vårt fra Git slik at vi kan laste ned og kjøre det på den eksterne maskinen. På den eksterne serveren som er koblet over SSH, skriv først ut SSH -tasten:

cat ~/.ssh/id_rsa.pub

Deretter lim inn denne tasten i Git -innstillingene som vi gjorde før for å sette opp Git -depotet vårt. Vi kan nå klone prosjektet vårt direkte til serveren. Forsikre deg om at du har sikkerhetskopiert prosjektet lokalt først, så det er på Git -serveren å laste ned.

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

Perfekt. Nå er alle filene her. Vi kan se dem med LS

ls

La oss nå begynne å sette opp serveren. Først kopierer du prosjektkatalogen din til et enkelt, minneverdig navn vi vil bruke til prosjektet.

cp -r yourproject whatyoucalledit

Hvor "WhatDyoucalledit" er det nye navnet på prosjektet ditt. Deretter må vi bygge et grunnleggende verktøy for å sette opp serveren. Vi vil lagre dette verktøyet og bruke det i fremtiden. For å bygge dette verktøyet, la oss opprette en brukerbinær for å definere hvordan vi redigerer et skript. Bruke bash, redigering/usr/bin/ascript

sudo nano /usr/bin/ascript

Sørg for å bruke sudo der, slik at du har tillatelser til å redigere filen. I filen, legg til disse linjene:

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

Husk at dette skriptet tar et argument, skriptnavnet, som $ 1. Først sjekker den om filen eksisterer, eller på annen måte oppretter den, legger til den første linjen som erklærer at skriptet er bash, endrer tillatelser, redigerer den og legger navnet til /etc /ascripts som lar oss lagre navnene på skriptene vi lager. Hvis filen allerede eksisterer, kan du bare endre tillatelser og redigere den. Lagre filen, og neste vil vi endre tillatelser. Så lenge vi bruker dette skriptet, trenger vi ikke å gjøre det igjen.

sudo chmod a+x /usr/bin/ascript

Perfekt. La oss nå lage et skript som heter Setup. Først for ikke å overvelde deg, men se på hvordan oppsettskriptet mitt ser ut. Vi vil gå gjennom hvordan dette skriptet skal se ut i prosjektet ditt, du trenger ikke alt i manuset mitt til å begynne med.

# !/BIN/BASH
# sudo chmod a+x skript/brukere
# ./scripts/usersetup
# SSH-KeenGen
# Prosjektkatalog
# Loggkommandoer
# Nano Config
# Git config
# Oppdater og installer
# Aktiver clamav antivirus
# Sett vertsnavn
# Oppsett postgres
# Oppsett database -sikkerhetskopi
# Deaktiver iptables
# Installer bitdefender
# Oppsett postfix
# Lage dirs
# Sett opp virtualenv
# Få og bygge avhengigheter
# Sett brannmurregler
# Installer PYPI -avhengigheter
pip3 install --upgrade opencv-python # == 4.5.4.60
pip3 install --upgrade opencv-contrib-python # == 4.5.4.60
# PIP-install OpenCV-Python == 4.5.5.64
# PIP-install OpenCV-Contrib-Python == 4.5.5.64
# Installer certbot
# Kjør certbot
# Last inn postserver på nytt
# Kopier sertifikater
# sudo cp /etc/letsencrypt/live/femmebabe.com/privkey.pem privkey.pem
# sudo cp /etc/letsencrypt/live/femmebabe.com/cert.pem cert.pem
# Patch Venv
# Angi brukerinnstillinger
# Angi tillatelser
# sudo chown -r team: brukere/var/løp/
# sudo chown root: root/run/sudo/ts -r
# sudo chmod 664 db.sqlite3
# sudo chown www-data: brukere db.sqlite3
# Kopier konfigurasjon og sett tillatelser
# Oppsettdatabase
# Injiser Pam Config og fjerne feil SSH -konfigurasjon
# sudo sed -i '' -e '$ d' /etc/pam.d/sshd
# sudo sed -i '' -e '$ d' /etc /profil
# Kopier søppelskript og angi tillatelser
# Last inn og aktiverer tjenester på nytt
# Aktiver Apache -moduler
# sudo a2dismod mpm_event
# sudo a2dismod mpm_worker
# sudo a2enmod mpm_prefork
# Deaktiver standardside
# Aktiver nettstedet vårt
# Last ned Daemon og start Apache, Postfix og OpenDkim
# Angi tillatelser
# Byttekonfigurasjon
# Init -bildetekstmotor
# Oppsett Git
# Vis IPv6 og OpenDkim for domenekonfigurasjon
# Oppsett fullført

Det er mye oppsett! In short, this code logs commands, configures nano and git, copies over files, downloads and installs ubuntu apt packages, python dependencies, configures postfix, configures postgresql (the database server) and loads the database, configures ufw (an uncomplicated firewall), disables iptables, downloads an antivirus, makes directories, clones Avhengigheter, installerer sertifikater og setter opp serveren, installerer konfigurasjon, starter og aktiverer Sever, tildeler bytte, angir tillatelser og skriver ut IP, IPv6 -adressen og OpenDkim -tasten. Ganske enkelt, men det ser ut som mye kode. Vi trenger ikke mye av dette fordi vi ikke har avhengighetene, vi bruker ikke selleri, selleri eller Daphne, men vi vil installere noen av dem uansett for å komme i gang. Legg merke til at denne koden har et domene som er erklært flere ganger.

Vi må også kjøpe et domenenavn (som er en liten årlig avgift). Jeg anbefaler Squarespace for å kjøpe et domene, oppsettet deres er intuitivt og enkelt å bruke. Du kan kjøpe et hvilket som helst domene etter eget valg, men jeg bruker domenet femmebabe.com i dette eksemplet. Når du har kjøpt et domene, kan du ta turen til Squarespace DNS -konfigurasjonspanelet og legge til en en post som peker domenet ditt på serveren med IP -adresse. Det skal se slik ut:

@ A xx.xx.xx.xx

Med @ operatøren som verten, som betyr at alle underdomener under dette domenet og rotdomenet alle vil omdirigere til serveren. Det er flere poster å erklære, men vi kan gå videre til disse når vi er klare til å sende post. Husk at det kan ta flere dager før du kan sende e -post fra serveren. DNS -postene vi setter vil ta tid å forplante seg.

Uansett, den eneste platen vi trenger å starte er en plate. Så nå kan vi fylle ut skriptet nedenfor i henhold til prosjektet vårt og kjøre det.

La oss starte med et mindre oppsettskript for bare å installere det vi trenger for en grunnleggende fremgang. Vi vil ikke bruke så mange avhengigheter eller PostgreSQL ennå, vi vil bare starte opp en grunnleggende HTTP -server og bekymre deg for å bekrefte den når det er gjort. Husk at for å få et HTTPS -sertifikat og kjøre serveren sikkert, må vi kjøpe et domene sammen med leie en server. Foreløpig, erstatt "Team" i denne filen med navnet på brukeren din, "DIR" med katalogen til prosjektet ditt, og levere e -post og domene i <> -kodene.

I tillegg, før vi kjører denne koden, må vi endre innstillingene til brannmuren vertsleverandøren støtter, om noen. Vanligvis er dette i fanen 'Nettverk' i hostingleverandøren din, eller hvis du er selvhotell, er det i "Port Videresending" -delen av ruteren din. Du vil også sette opp en statisk IP gjennom ruteren din med adressen til servermaskinen din, hvis du bruker selvhotell. Du må åpne følgende porter for å lese/skrive tilgang.

22 (ssh) 25 (Mail) 587 (Mail) 110 (Mail Client) 80 (http) 443 (https)

# !/BIN/BASH
# Loggkommandoer
# Nano Config
# Git config
# Oppdater og installer
# Aktiver clamav antivirus
# Sett vertsnavn
# Oppsett database -sikkerhetskopi
# Deaktiver iptables
# Sett opp virtualenv
# Installer certbot
# Kjør certbot
# Angi brukerinnstillinger
# Angi tillatelser
# sudo chown -r team: brukere/var/løp/
# sudo chown root: root/run/sudo/ts -r
# Last inn og aktiverer tjenester på nytt
# Aktiver Apache -moduler
# Last ned Daemon og start Apache, Postfix og OpenDkim
# Vis IPv6 og OpenDkim for domenekonfigurasjon

Før du kjører denne koden, må du sørge for at domenet du har kjøpt er koblet til serveren. For å gjøre dette, åpne en terminal på din lokale maskin, og kjør denne kommandoen med domenet ditt:

ping femmebabe.com # Sett inn domenet ditt her, etter ping

Hvis alt ser bra ut og serveren sender svar, er vi klare til å kjøre skriptet og installere pakker, samt starte, aktivere og bekrefte Apache -serveren vår.

Dette er ikke alt oppsettet som trengs for å konfigurere Postfix, vi vil se på det oppsettet mer senere. Foreløpig kjører du denne installasjonskoden, og det skal ta noen minutter å installere og bekrefte serveren din. Nok en gang, sørg for å erstatte navn, e -post og domenenavn i skriptet i henhold til navnet du kjøpte.

Nå som serveren er utstyrt, kan du gå til URL -en i hvilken som helst nettleser og sjekke for å sikre at serveren kjører HTTPS. Hvis det ikke er det, kan du prøve å vente en liten stund på at DNS -postene skal ta igjen og deretter kjøre følgende kommando for å prøve CertBot -sertifisering på nytt:

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

Så lenge du har konfigurert alt riktig, bør du kunne få tilgang til Apaches standardside bare for å vite at koden din fungerer og viser en live webside. Deretter, la oss redigere innstillingene.py for å endre standard feilsøkingsmodus til produksjon. Vi konfigurerer også domenet i innstillingene, så vel som interne IP -er.

nano yourproject/settings.py

I innstillingene, endre/legg til disse linjene.

# Nettstedskonf

Nå må vi konfigurere Apache2. La oss redigere konfigurasjonsfilen vi vil distribuere med denne linjen:

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

Denne konfigurasjonsfilen skal ha domenenavnet vårt i den, og navnet på brukeren og prosjektet. Jeg bruker domenenavnet femmebabe.com, brukernavn -teamet og prosjektnavnet 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>

Sørg for å erstatte navnet på prosjektet, katalogene og domenet i dette eksempelkoden når du konfigurerer serveren din. Nå må vi deaktivere standardsiden. Dette kan gjøres ved hjelp av bash.

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

Deretter kan vi aktivere standardsiden og laste inn Apache2 på nytt, også ved hjelp av bash. Husk å erstatte femmebabe med navnet på filen du erklærte når du redigerer i/etc/Apache2/Sites-tilgjengelig/.

sudo a2ensite femmebabe-le-ssl
sudo systemctl reload apache2

Gå tilbake til domenet ditt i Navbar. Du bør se nettstedet du konfigurerte i nettleseren din. Gratulerer! Hvis du ikke ser det, kan det hende du må gjøre noen endringer. Gjennomgå innstillingene i prosjektet ditt, Apache -konfigurasjonen, og sørg for at du ikke har noen feil, og kjør følgende kommandoer for å sjekke prosjektet for feil.

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

Hvis du har feil i Python -prosjektet ditt, kan du spore dem dit de er og fikse dem. Du kan ikke være i stand til å se alle feilene dine avhengig av hvor de er, så hvis du har en feil som ganske enkelt sier "Populate ikke er reentrant", rediger følgende fil i det virtuelle miljøet, register.py, for å avsløre feilen.

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

Bla til linje 83, der denne runtime -feilen blir hevet (løft RuntimeError ("Populate () ikke reentrant")), og legg til en kommentar før denne linjen, og legg deretter til, med samme innrykk, self.app_configs = {}. Dette ser slik ut:

                # Forhindre reentrant -anrop for å unngå å kjøre appconfig.ready ()
                # Metoder to ganger.
# Raise RunTimeError ("Populate () er ikke reentrant")

Du kan deretter sjekke prosjektet igjen og utsette feilen.

python manage.py check

Da kan du se feilen og fikse den. Når du har den fikset og koden samles uten feil, må du sørge for å endre filen tilbake slik at den ser slik ut:

                # Forhindre reentrant -anrop for å unngå å kjøre appconfig.ready ()
                # Metoder to ganger.
# self.app_configs = {}

Forutsatt at serveren er online, når vi gjør ytterligere endringer i den, må vi bruke følgende kommando for å laste inn serveren på nytt:

sudo systemctl reload apache2

Kjempebra! Men hva med å sende post? For å begynne å sende e -post, må vi først oppdatere domenekonfigurasjonen. Dette skal være i DNS -panelet ditt i Squarespace, eller hva som helst domenenavn registrator du valgte. Vi må også installere og legge til konfigurasjon, og kjøre noen få kommandoer.

La oss først få IPv6 -adressen til serveren. Vi åpner deretter DNS og legger til postene.

For å få serverens IPv6 -adresse, bruk denne kommandoen:

ip -6 addr

Nå kan vi legge til følgende poster i DNS -innstillingene. Postene mine ser slik ut. For dine poster bør du imidlertid erstatte IP -adressen med IP -en din (ikke 75.147.182.214, det er min). Legg også til domenet ditt i stedet for femmebabe.com, samt din IPv6 -adresse som ble funnet med forrige kommando (du kan ikke bruke min, FE80 :: 725a: FFF: FE49: 3E02). Ikke bekymre deg for Domainkey for nå, dette opprettes når vi setter opp Postfix, postserveren, med OpenDkim, og skriv ut tasten. Vi vil konfigurere dette sist.

@ EN N/a 75.147.182.214

@ MX 10 femmebabe.com

@ PTR N/a femmebabe.com

@ Txt N/a TXT @ V = SPF1 MX IP75.147.182.214ip6: Fe80 :: 725a: FFF: FE49: 3E02 ~ ALL

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

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

SendOnly._Domainkey Txt N/a

Nå må vi legge til litt vedvarende konfigurasjon for postfix. Alt vi trenger å gjøre er å sørge for at vi erstatter domenenavnet, femmebabe.com, med domenenavnet du bruker. La oss se på alle konfigurasjonsfilene en etter en, og installere dem i en katalog som heter Config i prosjektet vårt, for installasjon til OS.

nano config/etc_postfix_main.cf

Legg til denne teksten i filen

# Se /usr/share/postfix/main.cf.dist for en kommentert, mer komplett versjon
# Debian -spesifikt: Å spesifisere et filnavn vil forårsake det første
# Linje av den filen som skal brukes som navn.  Debian standard
# er /etc /mailname.
# myorigin = /etc /mailName
# Å legge til. Domene er MUAs jobb.
# Ukomment den neste linjen for å generere "forsinket post" advarsler
# forsinkelse_warning_time = 4h
# Se http://www.postfix.org/compatibility_readme.html - Standard til 3.6 på
# Ferske installasjoner.
# TLS -parametere
# Milter -konfigurasjon

Neste konfigurasjon!

nano config/etc_postfix_master.cf

Legg til disse linjene:

# 
# Postfix Master Process Configuration File.  For detaljer om formatet
# av filen, se masteren (5) manuell side (kommando: "man 5 master" eller
# Online: http://www.postfix.org/master.5.html).
# 
# Ikke glem å utføre "Postfix Reload" etter å ha redigert denne filen.
# 
# ============================================================================
# Tjenestetype Privat Unpriv Chroot Wakeup MaxProc Command + Args
# (ja) (ja) (nei) (aldri) (100)
# ============================================================================
# Smtp inet n - y - 1 postskjerm
# SMTPD Pass - - Y - - SMTPD
# dnsblog unix - - y - 0 dnsblog
# tlsproxy unix - - y - 0 tlsproxy
# Velg en: Aktiver innsending for bare loopback -klienter, eller for enhver klient.
# 127.0.0.1:Submission Inet N - Y - - SMTPD
# -o syslog_name = postfix/innsending
# -o smtpd_tls_security_level = kryptert
# -o smtpd_sasl_auth_enable = ja
# -o smtpd_tls_auth_only = ja
# -o smtpd_reject_unlisted_recipient = nei
# -o smtpd_client_restrictions = $ mua_client_restrictions
# -o smtpd_helo_restrictions = $ mua_helo_restrictions
# -o smtpd_sender_restrictions = $ MUA_SENDER_RESTRICTIONS
# -o smtpd_recipient_restrictions =
# -o smtpd_relay_restrictions = tillatelse_sasl_authenticated, avviser
# -O MILTER_MACRO_DAEMON_NAME = Opprinnelse
# Velg en: Aktiver SMTPS for bare loopback -klienter, eller for enhver klient.
# 127.0.0.1:SMTPS INET N - Y - - SMTPD
# SMTPS inet n - y - - SMTPD
# -o syslog_name = postfix/smtps
# -o smtpd_tls_wrappermode = ja
# -o smtpd_sasl_auth_enable = ja
# -o smtpd_reject_unlisted_recipient = nei
# -o smtpd_client_restrictions = $ mua_client_restrictions
# -o smtpd_helo_restrictions = $ mua_helo_restrictions
# -o smtpd_sender_restrictions = $ MUA_SENDER_RESTRICTIONS
# -o smtpd_recipient_restrictions =
# -o smtpd_relay_restrictions = tillatelse_sasl_authenticated, avviser
# -O MILTER_MACRO_DAEMON_NAME = Opprinnelse
# 628 inet n - y - - qmqpd
# QMGR UNIX N - N 300 1 OQMGR
# -o smtp_helo_timeout = 5 -o smtp_connect_timeout = 5
# 
# ======================================================================
# Grensesnitt til programvare for ikke-postfix. Sørg for å undersøke manualen
# Sider av programvaren som ikke er postfix for å finne ut hvilke alternativer den vil.
# 
# Mange av følgende tjenester bruker levering etter FIX (8)
# agent.  Se Pipe (8) Man -siden for informasjon om $ {mottaker}
# og andre alternativer for konvolutt.
# ======================================================================
# 
# Maildrop. Se Postfix MailDrop_readme -filen for detaljer.
# Spesifiser også i main.cf: maildrop_destination_recipient_limit = 1
# 
# 
# ======================================================================
# 
# Nyere Cyrus -versjoner kan bruke den eksisterende "LMTP" Master.cf -oppføringen.
# 
# Spesifiser i cyrus.conf:
# lmtp cmd = "lmtpd -a" listen = "localhost: lmtp" proto = tcp4
# 
# Spesifiser i main.cf ett eller flere av følgende:
# mailbox_transport = lmtp: inet: localhost
# virtual_transport = lmtp: inet: localhost
# 
# ======================================================================
# 
# Cyrus 2.1.5 (Amos Gouaux)
# Spesifiser også i main.cf: cyrus_destination_recipient_limit = 1
# 
# Cyrus Unix - N N - - Pipe
# Flags = drx bruker = cyrus argv =/cyrus/bin/leverer -e -r $ {avsender} -m $ {extension} $ {user}
# 
# ======================================================================
# Gammelt eksempel på levering via Cyrus.
# 
# Old -Cyrus Unix - N N - - Pipe
# Flags = r bruker = cyrus argv =/cyrus/bin/levere -e -m $ {extension} $ {bruker}
# 
# ======================================================================
# 
# Se Postfix UUCP_Readme -filen for konfigurasjonsdetaljer.
# 
# 
# Andre eksterne leveringsmetoder.
# 

Og OpenDkim -konfigurasjonen. OpenDkim identifiserer e -postservere med domenetaster for å gjøre dem sikrere. Uten det er ikke post signert og kan ikke komme til en innboks.

nano config/etc_default_opendkim

Legg til disse linjene:

# Merk: Dette er en arv konfigurasjonsfil. Det brukes ikke av OpenDkim
# Systemd -tjeneste. Bruk de tilsvarende konfigurasjonsparametere i
# /etc/opendkim.conf i stedet.
# 
# Tidligere ville man redigere standardinnstillingene her, og deretter utføre
# /lib/opendkim/opendkim.service.generate for å generere systemd overstyrer filer på
# /etc/systemd/system/opendkim.service.d/override.conf og
# /etc/tmpfiles.d/opendkim.conf. Selv om dette fortsatt er mulig, er det nå
# Anbefalt å justere innstillingene direkte i /etc/opendkim.conf.
# 
# Daemon_opts = ""
# Endre til/var/spool/postfix/run/openDkim for å bruke en Unix -stikkontakt med
# Postfix i en chroot:
# Rundir =/var/spool/postfix/run/openDkim
# 
# Ukomment å spesifisere en alternativ stikkontakt
# Merk at innstillingen dette vil overstyre enhver sokkelverdi i openDkim.conf
# misligholde:
# Lytt på alle grensesnitt på port 54321:
# Socket = inet: 54321
# Lytt på loopback på port 12345:
# Socket = inet: 12345@localhost
# Lytt på 192.0.2.1 på port 12345:
# Socket = inet: 12345@192.0.2.1

nano config/etc_dovecot_conf.d_10-master.conf

Legg til disse linjene:

# standard_process_limit = 100
# Default_client_limit = 1000
# Standard VSZ (virtuell minnestørrelse) grense for serviceprosesser. Dette er hovedsakelig
# ment å fange og drepe prosesser som lekker minne før de spiser opp
# alt.
# Default_vsz_limit = 256m
# Innloggingsbruker brukes internt av påloggingsprosesser. Dette er det mest upålitelige
# Bruker i Dovecot -systemet. Det skal ikke ha tilgang til noe i det hele tatt.
# Default_login_user = Dovenull
# Intern bruker brukes av uprivilegerte prosesser. Det skal være atskilt fra
# Innloggingsbruker, slik at påloggingsprosesser ikke kan forstyrre andre prosesser.
# standard_internal_user = dovecot
    # port = 143
    # port = 993
    # SSL = ja
  # Antall tilkoblinger som skal håndteres før du starter en ny prosess. Vanligvis
  # De eneste nyttige verdiene er 0 (ubegrenset) eller 1. 1 er sikrere, men 0
  # er raskere. <doc/wiki/loginprocess.txt>
  # Service_Count = 1
  # Antall prosesser for alltid å vente på flere forbindelser.
  # prosess_min_avail = 0
  # Hvis du angir Service_Count = 0, må du sannsynligvis vokse dette.
  # vsz_limit = $ standard_vsz_limit
    # port = 110
    # Port = 995
    # SSL = ja
    # port = 587
  # Lag inet lytter bare hvis du ikke kan bruke UNIX -kontakten ovenfor
  # inet_listener lmtp {
    # Unngå å synliggjøre LMTP for hele internett
    # adresse =
    # port =
  # }
  # Det meste av minnet går til mmap () ing filer. Det kan hende du må øke dette
  # Begrens hvis du har enorme postkasser.
  # vsz_limit = $ standard_vsz_limit
  # Maks. Antall IMAP -prosesser (tilkoblinger)
  # prosess_limit = 1024
  # Maks. Antall POP3 -prosesser (tilkoblinger)
  # prosess_limit = 1024
  # Maks. Antall SMTP -innsendingsprosesser (tilkoblinger)
  # prosess_limit = 1024
  # Auth_socket_Path peker på denne brukerdb -kontakten som standard. Det er vanligvis
  # brukt av Dovecot-LDA, Doveadm, muligens IMAP-prosess, etc. Brukere som har
  # Full tillatelser til denne kontakten kan få en liste over alle brukernavn og
  # Få resultatene fra alles UserDB -oppslag.
  # 
  # Standard 0666 -modus lar alle koble seg til kontakten, men
  # UserDB -oppslag vil bare lykkes hvis brukerdb returnerer et "uid" -felt som
  # Matcher innringers prosessens uid. Også hvis innringers uid eller GID samsvarer med
  # Sockets uid eller gid oppslaget lykkes. Noe annet forårsaker en fiasko.
  # 
  # For å gi den som ringer fulle tillatelser til å slå opp alle brukere, sett modus til
  # noe annet enn 0666 og Dovecot lar kjernen håndheve
  # Tillatelser (f.eks. 0777 tillater alle fulle tillatelser).
  # Authorner -prosessen kjøres som rot som standard, slik at den får tilgang
  # /etc/skygge. Hvis dette ikke er nødvendig, bør brukeren endres til
  # $ standard_internal_user.
  # Bruker = rot
  # Hvis DICT -proxy brukes, bør postprosesser ha tilgang til stikkontakten.
  # For eksempel: modus = 0660, gruppe = vmail og global mail_access_groups = vmail
    # modus = 0600
    # bruker =
    # gruppe =

Nok en gang, sørg for å erstatte domenet i alle disse filene, femmebabe.com, med domenet du valgte. Rediger neste fil, Dovecots konfigurasjon,

nano config/etc_dovecot_dovecot

Og legg til disse linjene

## Dovecot -konfigurasjonsfil
# Hvis du har det travelt, se http://wiki2.dovecot.org/quickconfiguration
# "DoveConf -n" -kommandoen gir en ren utgang av de endrede innstillingene. Bruk den
# I stedet for å kopiere og lime inn filer når du legger ut til Dovecot -adresselisten.
# '# 'Karakter og alt etter at det blir behandlet som kommentarer. Ekstra mellomrom
# og faner blir ignorert. Hvis du vil bruke noen av disse eksplisitt, kan du sette
# value inside quotes, eg.: key = "# røye og etterfølgende hvitrom "
# De fleste (men ikke alle) innstillinger kan overstyres av forskjellige protokoller og/eller
# Kilde/destinasjons -IP -er ved å plassere innstillingene i seksjoner, for eksempel:
# Protocol IMAP {}, lokal 127.0.0.1 {}, fjernkontroll 10.0.0.0/8 {}
# Standardverdier vises for hver innstilling, det kreves ikke
# de. Dette er imidlertid unntak fra dette: ingen seksjoner (f.eks. Namespace {})
# eller plugin -innstillinger legges til som standard, de er bare oppført som eksempler.
# Stier er også bare eksempler med at de virkelige standardene er basert på konfigurering
# alternativer. Stiene som er oppført her er for konfigurering -prefix =/usr
# --sysconfdir =/etc--localstatedir =/var
# Aktiver installerte protokoller
# En komma -separert liste over IP -er eller verter hvor du kan lytte til for tilkoblinger.
# "*" lytter i alle IPv4 -grensesnitt, "::" Lytter i alle IPv6 -grensesnitt.
# Hvis du vil spesifisere ikke-default-porter eller noe mer sammensatt,
# Rediger conf.d/master.conf.
# lytt = *, ::
# Basedatalog hvor du skal lagre runtime -data.
# base_dir =/var/run/dovecot/
# Navn på denne forekomsten. I multi-instans oppsett Doveadm og andre kommandoer
# kan bruke -i <forsøk_navn> for å velge hvilken forekomst som brukes (et alternativ
# til -c <config_path>). Forekomstnavnet legges også til Dovecot -prosesser
# I PS -utgang.
# Instance_name = dovecot
# Hilsen melding for klienter.
# Login_greeting = Dovecot klar.
# Plassskilt liste over pålitelige nettverksområder. Tilkoblinger fra disse
# IP -er har lov til å overstyre sine IP -adresser og porter (for logging og
# for autentiseringssjekker). deable_plainText_auth blir også ignorert for
# disse nettverkene. Vanligvis vil du spesifisere IMAP -proxy -serverne her.
# LOGIN_TRUSTED_NETWORKS =
# Plasserskilt liste over loggadgangskontrollstakninger (f.eks. TCPWRAP)
# login_access_sockets =
# Med proxy_maybe = ja hvis proxy -destinasjonen samsvarer med noen av disse IP -ene, ikke gjør
# proxying. Dette er ikke nødvendig normalt, men kan være nyttig hvis destinasjonen
# IP er f.eks. en belastningsbalansers IP.
# Auth_Proxy_self =
# Vis flere ordrike prosesstitler (i PS). For tiden viser brukernavn og
# IP -adresse. Nyttig for å se hvem som faktisk bruker IMAP -prosessene
# (f.eks. Delte postkasser eller hvis samme uid brukes til flere kontoer).
# verbose_proctitle = nei
# Skulle alle prosesser drepes når Dovecot -mesterprosessen slås av.
# Å sette dette til "ingen" betyr at Dovecot kan oppgraderes uten
# tvinger eksisterende klientforbindelser til å lukke (selv om det også kan være
# Et problem hvis oppgraderingen er f.eks. på grunn av en sikkerhetsretting).
# ShutDown_Clients = Ja
# Hvis ikke-null, kjør e-postkommandoer via disse mange tilkoblingene til Doveadm-serveren,
# i stedet for å kjøre dem direkte i samme prosess.
# doveadm_worker_count = 0
# Unix Socket eller Host: Port brukt til tilkobling til Doveadm Server
# doveadm_socket_path = doveadm-server
# Plassskilt liste over miljøvariabler som er bevart på Dovecot
# Oppstart og sendt videre til alle sine barneprosesser. Du kan også gi
# Nøkkel = Verdipar for alltid å angi spesifikke innstillinger.
# Import_Niljø = TZ
## 
## Innstillinger for ordbokserver
## 
# Ordbok kan brukes til å lagre nøkkel = verdilister. Dette brukes av flere
# plugins. Ordboken kan nås enten direkte eller om en
# ordbokserver. Følgende dikter blokkerer kartordboksnavn til URI
# Når serveren brukes. Disse kan deretter refereres til med URI -er i format
# "Proxy :: <name>".
  # kvote = mysql: /etc/dovecot/dovecot-dict-sql.conf.ext
# Det meste av den faktiske konfigurasjonen blir inkludert nedenfor. Filnavnene er
# først sortert etter deres ASCII -verdi og analysert i den rekkefølgen. 00-prefiksene
# I filnavn er ment å gjøre det lettere å forstå bestillingen.
# En konfigurasjonsfil kan også prøvd å bli inkludert uten å gi en feil hvis
# Det er ikke funnet:
# Lar Dovecot lytte til alle inngangstilkoblinger (IPv4 / IPv6)

Legg til et passord for Dovecot -brukeren:

nano config/etc_dovecot_passwd

Den første delen av filen, før tykktarmen, er brukernavnet. Den siste delen, "YourPassword", betegner passordet du vil gi e -postserveren din.

team:{plain}yourpassword

Neste, OpenDkim -konfigurasjonen

nano config/etc_opendkim.conf

Og legg til disse linjene:

# Dette er en grunnleggende konfigurasjon for signering og verifisering. Det kan lett være
# Tilpasset for å passe til en grunnleggende installasjon. Se OpenDkim.conf (5) og
# /usr/share/doc/opendkim/examples/opendkim.conf.sample for komplett
# Dokumentasjon av tilgjengelige konfigurasjonsparametere.
# Logghvrett nei
# Vanlige signerings- og verifiseringsparametere. I Debian er "fra" overskriften
# overordnet, fordi det ofte er identitetsnøkkelen som brukes av omdømme systemer
# og dermed noe sikkerhetsfølsom.
# Signeringsdomen, velger og nøkkel (påkrevd). Utfør for eksempel signering
# for domene "Eksempel.com" med velgeren "2020" (2020._domainkey.example.com),
# Bruke den private nøkkelen som er lagret i /etc/dkimkeys/example.private. Mer granulær
# Oppsettalternativer finner du i /usr/share/doc/opendkim/readme.opendkim.
# Domene eksempel.com
# Velger 2020
# Keyfile /etc/dkimkeys/example.private
# I Debian kjører OpenDkim som bruker "OpenDkim". En Umask på 007 er påkrevd når
# Bruke en lokal stikkontakt med MTAs som får tilgang til kontakten som en ikke-privilegert
# Bruker (for eksempel postfix). Det kan hende du må legge til bruker "postfix" til gruppen
# "OpenDkim" i så fall.
# Stikkontakt for MTA -tilkoblingen (påkrevd). Hvis MTA er inne i et chroot -fengsel,
# Det må sikres at kontakten er tilgjengelig. I Debian løper Postfix inn
# en chroot in/var/spool/postfix, derfor må en unix -stikkontakt være
# Konfigurert som vist på den siste linjen nedenfor.
# Socket Local: /run/opendkim/opendkim.sock
# Socket Inet: 8891@localhost
# Stikkontakt: 8891
# Verter for å signere i stedet for å bekrefte, er standard 127.0.0.1. Se
# Operasjonsdelen av OpenDkim (8) for mer informasjon.
# InternalHosts 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12
# Trustankeret muliggjør DNSSEC. I Debian er det gitt tillitsankerfilen
# av pakken DNS-root-data.
# Nameservere 127.0.0.1
# Kartdomener inn fra adresser til nøkler som brukes til å signere meldinger
# Et sett med interne verter hvis post skal signeres

nano config/etc_default_opendkim

Og legg til disse linjene

# Merk: Dette er en arv konfigurasjonsfil. Det brukes ikke av OpenDkim
# Systemd -tjeneste. Bruk de tilsvarende konfigurasjonsparametere i
# /etc/opendkim.conf i stedet.
# 
# Tidligere ville man redigere standardinnstillingene her, og deretter utføre
# /lib/opendkim/opendkim.service.generate for å generere systemd overstyrer filer på
# /etc/systemd/system/opendkim.service.d/override.conf og
# /etc/tmpfiles.d/opendkim.conf. Selv om dette fortsatt er mulig, er det nå
# Anbefalt å justere innstillingene direkte i /etc/opendkim.conf.
# 
# Daemon_opts = ""
# Endre til/var/spool/postfix/run/openDkim for å bruke en Unix -stikkontakt med
# Postfix i en chroot:
# Rundir =/var/spool/postfix/run/openDkim
# 
# Ukomment å spesifisere en alternativ stikkontakt
# Merk at innstillingen dette vil overstyre enhver sokkelverdi i openDkim.conf
# misligholde:
# Lytt på alle grensesnitt på port 54321:
# Socket = inet: 54321
# Lytt på loopback på port 12345:
# Socket = inet: 12345@localhost
# Lytt på 192.0.2.1 på port 12345:
# Socket = inet: 12345@192.0.2.1

Når vi er klare til å sette opp vår postfix -server, kjører vi koden nedenfor, med det aktuelle domenenavnet innebygd. Begynn med å lage et skript

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

Nå, i Nano, tekstredigereren, redigerer du denne filen slik at den inneholder domenenavnet ditt i stedet for femmebabe.com.

# !/BIN/BASH
# Oppsett postfix

Kjør nå det ferdige skriptet for å konfigurere Postfix, OpenDkim og Dovecot.

./scripts/postfixsetup

Når dette skriptet har kjørt, kopierer du den siste linjen det skriver ut og lim det inn i DNS -konfigurasjonen din som verdien for SendOnly._DomainKey. Dette er OpenDkim -nøkkelen som brukes til å identifisere domenet ditt når du sender sikker post.

Kjempebra! I løpet av få dager skal du kunne sende e -post fra serveren, forutsatt at alt er konfigurert riktig.

Hvis du bare konfigurerte DNS for e -postserveren din, bør det ta mindre enn 72 timer for postene å oppdatere. Det er vanligvis mye raskere. Du kan sjekke om serveren din fungerer ved å bruke denne kommandoen, leverte e -posten din:

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

Hvis alt ser ut til å fungere riktig, bør du kunne sende e -post med serveren din. Hvis det ikke fungerer, kan du prøve å se på loggene for å se hva feilen kan være.

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

Dette vil tilby ordentlig informasjon om e -post som blir sendt av serveren og om den fungerer som den skal. Du skal kunne se e -posten i innboksen din også, hvis den ikke er der, sjekk spam -mappen din.

Du må også konfigurere innstillingene dine i innstillingene. Legg til eller erstatt disse linjene i innstillingene dine

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

Legg merke til at vi bruker en konfigurasjonsfil for å få passordet. La oss laste inn denne filen i innstillingene slik, helt i begynnelsen av filen:

# Åpne og last inn konfigurasjon

La oss opprette denne filen og legge til en hemmelig nøkkel til den, så vel som e -postpassordet. For å generere en hemmelig nøkkel, bruk denne kommandoen, med hvilken lengde du vil på slutten:

openssl rand -base64 64

Kopier nå teksten som åpner og redigerer /etc/config.json

sudo nano /etc/config.json

Legg til følgende linjer i filen din, med nøkkelen som åpnes generert som den hemmelige nøkkelen.

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

JSON -formatet er enkelt og enkelt å bruke, vi kan erklære andre nøkler vi vil bruke i prosjektet vårt på denne måten også, og holde dem adskilt fra prosjektkatalogen vår, slik at andre brukere ikke kan skrive til dem, og derfor kan de ikke leses fra prosjektkatalogen vår alene. Dette anbefales praksis for API -nøkler, hvorav vi vil bruke mer enn noen få her.

Du vil også sikkerhetskopiere prosjektet ditt for å sikre at alt er lagret, og at du vil kunne gjenopprette arbeidet ditt senere, selv om du ikke lenger ønsker å leie en server.

sudo backup

Prøv nå å sende en HTML -e -post fra webserveren, forutsatt at det å sende en fra kommandolinjen fungerer. Spør din brukerforekomst i skallet, og send en HTML -e -post til den brukeren gjennom Django. Endre navnet mitt i koden, Charlotte, til brukernavnet ditt.

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

Hvis den første kommandoen ikke fungerer, må du sørge for å bruke

source venv/bin/activate

Forutsatt at alt er satt opp riktig, vil du nå få en velkomst -e -post i postkassen din sendt av webappen din. God jobb! Du har kommet langt.

Jeg ønsket å legge til, hvis du noen gang sliter med noen feil i det hele tatt mens du jobber med et prosjekt som dette, ikke nøl med å søke etter svar og be om hjelp. Google, blant andre søkemotorer, er gode ressurser til å søke etter programmeringshjelp. Bare søk etter feilen du får, så vil du kunne se hvordan andre mennesker løser problemet. Du er også velkommen til å kontakte meg, lærerne dine (lærere, professorer, veiledere), eventuelle jevnaldrende på internett som er tilgjengelige for programmeringshjelp, eller konsultere denne boken igjen eller andre ressurser for å finne løsninger på problemene du opplever. Jeg forstår at dette ikke er lett, men selv om du har lest i så langt og ikke skriver noen kode, lærer du mye om å bygge en webapp fra bunnen av. Klapp deg selv på baksiden, du gjør en god jobb.

Takk for at du tok deg tid til å lese denne tredje utgaven webutviklingsguide. I fremtidige utgaver vil jeg inkludere flere av de viktige eksemplene som er omtalt i begynnelsen av dokumentet, og vi vil dykke mye dypere inn i verden av programvare og maskinvareutvikling. Følg med for hva som skal komme, og jeg ser frem til å lære deg hvordan du bygger utrolig programvare. Vi sees i neste utgave!